Type safety w generics

- rm langchain_core dependency
- replace callbacks w run tree
- rm Runnable dependency
- rm non-state Graph
- rm managed values
- rm entrypoint/task/call
- rm async methods
- rm shallow checkpointer
- rm messages stream mode
- rm debug flag
- rm remote graph

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -1,60 +1,44 @@
 name: "\U0001F41B Bug Report"
-description: Report a bug in LangGraph. To report a security issue, please instead use the security option (below). For questions, please use the LangChain forum (below).
-labels: ["bug"]
-type: bug
+description: Report a bug in LangGraph. To report a security issue, please instead use the security option below. For questions, please use the GitHub Discussions.
+labels: ["02 Bug Report"]
 body:
   - type: markdown
     attributes:
-      value: |
-        Thank you for taking the time to file a bug report.
-
-        For usage questions, feature requests and general design questions, please use the [LangChain Forum](https://forum.langchain.com/).
-
-        Check these before submitting to see if your issue has already been reported, fixed or if there's another way to solve your problem:
-
-        * [Documentation](https://docs.langchain.com/oss/python/langgraph/overview),
-        * [API Reference Documentation](https://reference.langchain.com/python/),
-        * [LangChain ChatBot](https://chat.langchain.com/)
-        * [GitHub search](https://github.com/langchain-ai/langgraph),
-        * [LangChain Forum](https://forum.langchain.com/),
+      value: >
+        Thank you for taking the time to file a bug report. 
+        
+        Use this to report BUGS in LangGraph. For usage questions, feature requests and general design questions, please use [GitHub Discussions](https://github.com/langchain-ai/langgraph/discussions).
+        
+        Relevant links to check before filing a bug report to see if your issue has already been reported, fixed or
+        if there's another way to solve your problem:
+        
+        [LangGraph Github Discussions](https://github.com/langchain-ai/langgraph/discussions),
+        [LangGraph Github Issues](https://github.com/langchain-ai/langgraph/issues),
+        [LangGraph how-to guides](https://langchain-ai.github.io/langgraph/how-tos/).
+        [LangChain documentation with the integrated search](https://python.langchain.com/docs/get_started/introduction),
+        [GitHub search](https://github.com/langchain-ai/langgraph),
   - type: checkboxes
     id: checks
     attributes:
       label: Checked other resources
-      description: Please confirm and check all the following options.
+      description: Before submitting this issue, please confirm that you have completed all the steps below by checking each option. These steps help ensure your issue is well-defined, relevant, and actionable.
       options:
-        - label: This is a bug, not a usage question.
+        - label: This is a bug, not a usage question. For questions, please use GitHub Discussions.
           required: true
-        - label: I added a clear and descriptive title that summarizes this issue.
+        - label: I added a clear and detailed title that summarizes the issue.
           required: true
-        - label: I used the GitHub search to find a similar question and didn't find it.
+        - label: I read what a minimal reproducible example is (https://stackoverflow.com/help/minimal-reproducible-example).
           required: true
-        - label: I am sure that this is a bug in LangGraph rather than my code.
-          required: true
-        - label: The bug is not resolved by updating to the latest stable version of LangGraph (or the specific integration package).
-          required: true
-        - label: This is not related to the langchain-community package.
-          required: true
-        - label: I posted a self-contained, minimal, reproducible example. A maintainer can copy it and run it AS IS.
+        - label: I included a self-contained, minimal example that demonstrates the issue INCLUDING all the relevant imports. The code run AS IS to reproduce the issue.
           required: true
   - type: textarea
     id: reproduction
     validations:
       required: true
     attributes:
-      label: Reproduction Steps / Example Code (Python)
+      label: Example Code
       description: |
         Please add a self-contained, [minimal, reproducible, example](https://stackoverflow.com/help/minimal-reproducible-example) with your use case.
-
-        If a maintainer can copy it, run it, and see it right away, there's a much higher chance that you'll be able to get help.
-
-        **Important!**
-
-        * Avoid screenshots, as they are hard to read and (more importantly) don't allow others to copy-and-paste your code.
-        * Reduce your code to the minimum required to reproduce the issue if possible.
-
-        (This will be automatically formatted into code, so no need for backticks.)
-      render: python
       placeholder: |
         from langgraph.graph import StateGraph
 
@@ -63,13 +47,17 @@ body:
           
         chain = StateGraph(list)
         chain.invoke('Hello!')
+      render: python
   - type: textarea
+    id: error
+    validations:
+      required: false
     attributes:
       label: Error Message and Stack Trace (if applicable)
       description: |
-        If you are reporting an error, please copy and paste the full error message and
-        stack trace.
-        (This will be automatically formatted into code, so no need for backticks.)
+        If you are reporting an error, please include the full error message and stack trace.
+      placeholder: |
+        Exception + full stack trace
       render: shell
   - type: textarea
     id: description
@@ -90,18 +78,7 @@ body:
     attributes:
       label: System Info
       description: |
-        Please share your system info with us.
-
-        Run the following command in your terminal and paste the output here:
-
-        `python -m langchain_core.sys_info`
-
-        or if you have an existing python interpreter running:
-
-        ```python
-        from langchain_core import sys_info
-        sys_info.print_sys_info()
-        ```
+        python -m langchain_core.sys_info
       placeholder: |
         python -m langchain_core.sys_info
     validations:

.github/ISSUE_TEMPLATE/config.yml

@@ -1,15 +1,15 @@
 blank_issues_enabled: false
 version: 2.1
 contact_links:
-  - name: 💬 LangChain Forum
-    url:  https://forum.langchain.com/
-    about: General community discussions and support
-  - name: 📚 LangGraph Documentation
-    url: https://docs.langchain.com/oss/python/langgraph/overview
-    about: View the official LangGraph documentation
-  - name: 📚 API Reference Documentation
-    url: https://reference.langchain.com/python/
-    about: View the official LangGraph API reference documentation
-  - name: 📚 Documentation issue
-    url: https://github.com/langchain-ai/docs/issues/new?template=02-langgraph.yml
-    about: Report an issue related to the LangGraph documentation
+  - name: 🤔 Question or Problem
+    about: Ask a question or ask about a problem in GitHub Discussions.
+    url: https://github.com/langchain-ai/langgraph/discussions/categories/q-a
+  - name: Feature Request
+    url: https://github.com/langchain-ai/langgraph/discussions/categories/ideas
+    about: Suggest a feature or an idea
+  - name: Show and tell
+    about: Show what you built with LangChain
+    url: https://github.com/langchain-ai/langgraph/discussions/categories/show-and-tell
+  - name: Slack
+    url:  https://www.langchain.com/join-community
+    about: General community discussions

.github/ISSUE_TEMPLATE/documentation.yml

@@ -0,0 +1,19 @@
+name: Documentation
+description: Report an issue related to the LangGraph documentation.
+title: "DOC: <Please write a comprehensive title after the 'DOC: ' prefix>"
+labels: [03 - Documentation]
+
+body:
+- type: textarea
+  attributes: 
+    label: "Issue with current documentation:"
+    description: >
+      Please make sure to leave a reference to the document/code you're
+      referring to.
+
+- type: textarea
+  attributes:
+    label: "Idea or request for content:"
+    description: >
+      Please describe as clearly as possible what topics you think are missing
+      from the current documentation.

.github/ISSUE_TEMPLATE/privileged.yml

@@ -1,29 +1,25 @@
 name: 🔒 Privileged
-description: You are a LangGraph maintainer, or was asked directly by a maintainer to create an issue here. If not, check the other options.
+description: You are a LangChain maintainer, or was asked directly by a maintainer to create an issue here. If not, check the other options.
 body:
   - type: markdown
     attributes:
       value: |
-        Thanks for your interest in LangGraph! 🚀
-
-        If you are not a LangGraph maintainer or were not asked directly by a maintainer to create an issue, then please start the conversation on the [LangChain Forum](https://forum.langchain.com/) instead.
-
-        You are a LangGraph maintainer if you maintain any of the packages inside of the LangGraph repository 
-        or are a regular contributor to LangGraph with previous merged merged pull requests.
+        Thanks for your interest in LangChain! 🚀
+        
+        If you are not a LangChain maintainer or were not asked directly by a maintainer to create an issue, then please start the conversation in a [Question in GitHub Discussions](https://github.com/langchain-ai/langchain/discussions/categories/q-a) instead.
+        
+        You are a LangChain maintainer if you maintain any of the packages inside of the LangChain repository 
+        or are a regular contributor to LangChain with previous merged merged pull requests.
   - type: checkboxes
     id: privileged
     attributes:
       label: Privileged issue
       description: Confirm that you are allowed to create an issue here.
       options:
-        - label: I am a LangGraph maintainer, or was asked directly by a LangGraph maintainer to create an issue here.
+        - label: I am a LangChain maintainer, or was asked directly by a LangChain maintainer to create an issue here.
           required: true
   - type: textarea
     id: content
     attributes:
       label: Issue Content
       description: Add the content of the issue here.
-  - type: markdown
-    attributes:
-      value: |
-        Community members should **NOT** work on Privileged issues unless these issues have been explicitly marked with a "help-wanted" tag.

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,31 +0,0 @@
-Thank you for contributing to LangGraph! Follow these steps to mark your pull request as ready for review. **If any of these steps are not completed, your PR will not be considered for review.**
-
-- [ ] **PR title**: Follows the format: {TYPE}({SCOPE}): {DESCRIPTION}
-  - Examples:
-    - feat(core): add multi-tenant support
-    - fix(cli): resolve flag parsing error
-    - docs(openai): update API usage examples
-  - Allowed `{TYPE}` values:
-    - feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert, release
-  - Allowed `{SCOPE}` values (optional):
-    - langgraph, docs, cli, checkpoint, checkpoint-postgres, checkpoint-sqlite, prebuilt, scheduler-kafka, sdk-py
-  - Once you've written the title, please delete this checklist item; do not include it in the PR.
-
-- [ ] **PR message**: ***Delete this entire checklist*** and replace with
-  - **Description:** a description of the change. Include a [closing keyword](https://docs.github.com/en/issues/tracking-your-work-with-issues/using-issues/linking-a-pull-request-to-an-issue#linking-a-pull-request-to-an-issue-using-a-keyword) if applicable.
-  - **Issue:** the issue # it fixes, if applicable
-  - **Dependencies:** any dependencies required for this change
-  - **Twitter handle:** if your PR gets announced, and you'd like a mention, we'll gladly shout you out!
-
-- [ ] **Add tests and docs**: If you're adding a new integration, you must include:
-  1. A test for the integration, preferably unit tests that do not rely on network access,
-  2. An example notebook showing its use. It lives in `docs/docs/integrations` directory.
-
-- [ ] **Lint and test**: Run `make format`, `make lint` and `make test` from the root of the package(s) you've modified. We will not consider a PR unless these three are passing in CI. See [contribution guidelines](https://docs.langchain.com/oss/python/contributing/overview) for more.
-
-Additional guidelines:
-
-- Make sure optional dependencies are imported within a function.
-- Please do not add dependencies to `pyproject.toml` files (even optional ones) unless they are **required** for unit tests.
-- Most PRs should not touch more than one package.
-- Changes should be backwards compatible.

.github/actions/poetry_setup/action.yml

@@ -0,0 +1,88 @@
+# An action for setting up poetry install with caching.
+# Using a custom action since the default action does not
+# take poetry install groups into account.
+# Action code from:
+# https://github.com/actions/setup-python/issues/505#issuecomment-1273013236
+name: poetry-install-with-caching
+description: Poetry install with support for caching of dependency groups.
+
+inputs:
+  python-version:
+    description: Python version, supporting MAJOR.MINOR only
+    required: true
+
+  poetry-version:
+    description: Poetry version
+    required: true
+
+  cache-key:
+    description: Cache key to use for manual handling of caching
+    required: true
+
+runs:
+  using: composite
+  steps:
+    - uses: actions/setup-python@v5
+      name: Setup python ${{ inputs.python-version }}
+      id: setup-python
+      with:
+        python-version: ${{ inputs.python-version }}
+
+    - uses: actions/cache@v3
+      id: cache-bin-poetry
+      name: Cache Poetry binary - Python ${{ inputs.python-version }}
+      env:
+        SEGMENT_DOWNLOAD_TIMEOUT_MIN: "1"
+      with:
+        path: |
+          /opt/pipx/venvs/poetry
+        # This step caches the poetry installation, so make sure it's keyed on the poetry version as well.
+        key: bin-poetry-${{ runner.os }}-${{ runner.arch }}-py-${{ inputs.python-version }}-${{ inputs.poetry-version }}
+
+    - name: Refresh shell hashtable and fixup softlinks
+      if: steps.cache-bin-poetry.outputs.cache-hit == 'true'
+      shell: bash
+      env:
+        POETRY_VERSION: ${{ inputs.poetry-version }}
+        PYTHON_VERSION: ${{ inputs.python-version }}
+      run: |
+        set -eux
+
+        # Refresh the shell hashtable, to ensure correct `which` output.
+        hash -r
+
+        # `actions/cache@v3` doesn't always seem able to correctly unpack softlinks.
+        # Delete and recreate the softlinks pipx expects to have.
+        rm /opt/pipx/venvs/poetry/bin/python
+        cd /opt/pipx/venvs/poetry/bin
+        ln -s "$(which "python$PYTHON_VERSION")" python
+        chmod +x python
+        cd /opt/pipx_bin/
+        ln -s /opt/pipx/venvs/poetry/bin/poetry poetry
+        chmod +x poetry
+
+        # Ensure everything got set up correctly.
+        /opt/pipx/venvs/poetry/bin/python --version
+        /opt/pipx_bin/poetry --version
+
+    - name: Install poetry
+      if: steps.cache-bin-poetry.outputs.cache-hit != 'true'
+      shell: bash
+      env:
+        POETRY_VERSION: ${{ inputs.poetry-version }}
+        PYTHON_VERSION: ${{ inputs.python-version }}
+      # Install poetry using the python version installed by setup-python step.
+      run: pipx install "poetry==$POETRY_VERSION" --python '${{ steps.setup-python.outputs.python-path }}' --verbose
+
+    - name: Restore pip and poetry cached dependencies
+      uses: actions/cache@v3
+      env:
+        SEGMENT_DOWNLOAD_TIMEOUT_MIN: "4"
+      with:
+        path: |
+          ~/.cache/pip
+          ~/.cache/pypoetry/virtualenvs
+          ~/.cache/pypoetry/cache
+          ~/.cache/pypoetry/artifacts
+          ./.venv
+        key: py-deps-${{ runner.os }}-${{ runner.arch }}-py-${{ inputs.python-version }}-poetry-${{ inputs.poetry-version }}-${{ inputs.cache-key }}-${{ hashFiles('./poetry.lock') }}

.github/dependabot.yml

@@ -1,111 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "weekly"
-      day: "monday"
-    groups:
-      all-dependencies:
-        patterns:
-          - "*"
-
-  - package-ecosystem: "uv"
-    directory: "/libs/checkpoint"
-    schedule:
-      interval: "weekly"
-      day: "monday"
-    groups:
-      all-dependencies:
-        patterns:
-          - "*"
-  - package-ecosystem: "uv"
-    directory: "/libs/checkpoint-conformance"
-    schedule:
-      interval: "weekly"
-      day: "monday"
-    groups:
-      all-dependencies:
-        patterns:
-          - "*"
-
-
-  - package-ecosystem: "uv"
-    directory: "/libs/checkpoint-postgres"
-    schedule:
-      interval: "weekly"
-      day: "monday"
-    groups:
-      all-dependencies:
-        patterns:
-          - "*"
-
-  - package-ecosystem: "uv"
-    directory: "/libs/checkpoint-sqlite"
-    schedule:
-      interval: "weekly"
-      day: "monday"
-    groups:
-      all-dependencies:
-        patterns:
-          - "*"
-
-  - package-ecosystem: "uv"
-    directory: "/libs/cli"
-    schedule:
-      interval: "weekly"
-      day: "monday"
-    groups:
-      all-dependencies:
-        patterns:
-          - "*"
-
-  - package-ecosystem: "uv"
-    directory: "/libs/langgraph"
-    schedule:
-      interval: "weekly"
-      day: "monday"
-    groups:
-      all-dependencies:
-        patterns:
-          - "*"
-
-  - package-ecosystem: "uv"
-    directory: "/libs/prebuilt"
-    schedule:
-      interval: "weekly"
-      day: "monday"
-    groups:
-      all-dependencies:
-        patterns:
-          - "*"
-
-  - package-ecosystem: "uv"
-    directory: "/libs/sdk-py"
-    schedule:
-      interval: "weekly"
-      day: "monday"
-    groups:
-      all-dependencies:
-        patterns:
-          - "*"
-
-  - package-ecosystem: "npm"
-    directory: "/libs/cli/js-examples"
-    schedule:
-      interval: "weekly"
-      day: "monday"
-    groups:
-      all-dependencies:
-        patterns:
-          - "*"
-
-  - package-ecosystem: "npm"
-    directory: "/libs/cli/js-monorepo-example"
-    schedule:
-      interval: "weekly"
-      day: "monday"
-    groups:
-      all-dependencies:
-        patterns:
-          - "*"

.github/images/logo-dark.svg

@@ -1,5 +0,0 @@
-<svg width="472" height="100" viewBox="0 0 472 100" fill="none" xmlns="http://www.w3.org/2000/svg">
-<rect x="100" y="6.10352e-05" width="100" height="100" rx="20" transform="rotate(90 100 6.10352e-05)" fill="#161F34"/>
-<path d="M32.1494 67.8579H45.2266C45.2246 75.0778 39.3716 80.93 32.1514 80.9302C24.9301 80.9301 19.0756 75.0762 19.0752 67.855C19.0752 60.6341 24.9288 54.78 32.1494 54.7788V67.8579ZM67.8691 54.7788C75.0906 54.779 80.9443 60.6335 80.9443 67.855C80.944 75.0762 75.0904 80.93 67.8691 80.9302C60.6488 80.9301 54.7949 75.0778 54.793 67.8579H67.8594V54.7788C67.8626 54.7788 67.8659 54.7788 67.8691 54.7788ZM67.8691 19.0757C75.0906 19.0759 80.9443 24.9304 80.9443 32.1519C80.944 39.3731 75.0904 45.2269 67.8691 45.2271C67.8659 45.2271 67.8626 45.2261 67.8594 45.2261V32.1479H54.793C54.795 24.9281 60.6489 19.0758 67.8691 19.0757ZM32.1514 19.0757C39.3716 19.0759 45.2246 24.9281 45.2266 32.1479H32.1494V45.2261C24.929 45.2249 19.0755 39.3725 19.0752 32.1519C19.0752 24.9303 24.9299 19.0758 32.1514 19.0757Z" fill="#7FC8FF"/>
-<path d="M142.427 70.248V65.748H153.227V32.748H142.427V28.248H158.147V65.748H168.947V70.248H142.427ZM189.174 70.608C182.454 70.608 177.894 67.248 177.894 61.668C177.894 55.548 182.154 52.128 190.194 52.128H199.194V50.028C199.194 46.068 196.374 43.668 191.574 43.668C187.254 43.668 184.374 45.708 183.774 48.828H178.854C179.574 42.828 184.434 39.288 191.814 39.288C199.614 39.288 204.114 43.188 204.114 50.328V63.708C204.114 65.328 204.714 65.748 206.094 65.748H207.654V70.248H204.954C200.874 70.248 199.494 68.508 199.434 65.508C197.514 68.268 194.454 70.608 189.174 70.608ZM189.534 66.408C195.654 66.408 199.194 62.868 199.194 57.768V56.268H189.714C185.334 56.268 182.874 57.888 182.874 61.368C182.874 64.368 185.454 66.408 189.534 66.408ZM216.601 70.248V39.648H220.861L221.521 43.788C223.321 41.448 226.321 39.288 231.121 39.288C237.601 39.288 243.001 42.948 243.001 52.848V70.248H238.081V53.148C238.081 47.028 235.201 43.788 230.281 43.788C224.941 43.788 221.521 47.928 221.521 53.988V70.248H216.601ZM266.348 82.608C258.548 82.608 253.088 78.948 252.308 72.228H257.348C258.188 76.068 261.608 78.228 266.708 78.228C273.128 78.228 276.608 75.228 276.608 68.568V64.968C274.568 68.448 271.268 70.608 266.108 70.608C257.648 70.608 251.408 64.908 251.408 54.948C251.408 45.588 257.648 39.288 266.108 39.288C271.268 39.288 274.688 41.508 276.608 44.928L277.268 39.648H281.528V68.748C281.528 77.568 276.848 82.608 266.348 82.608ZM266.588 66.228C272.588 66.228 276.668 61.608 276.668 55.068C276.668 48.348 272.588 43.668 266.588 43.668C260.528 43.668 256.448 48.288 256.448 54.948C256.448 61.608 260.528 66.228 266.588 66.228ZM303.555 82.608C295.755 82.608 290.295 78.948 289.515 72.228H294.555C295.395 76.068 298.815 78.228 303.915 78.228C310.335 78.228 313.815 75.228 313.815 68.568V64.968C311.775 68.448 308.475 70.608 303.315 70.608C294.855 70.608 288.615 64.908 288.615 54.948C288.615 45.588 294.855 39.288 303.315 39.288C308.475 39.288 311.895 41.508 313.815 44.928L314.475 39.648H318.735V68.748C318.735 77.568 314.055 82.608 303.555 82.608ZM303.795 66.228C309.795 66.228 313.875 61.608 313.875 55.068C313.875 48.348 309.795 43.668 303.795 43.668C297.735 43.668 293.655 48.288 293.655 54.948C293.655 61.608 297.735 66.228 303.795 66.228ZM327.862 70.248V65.748H335.422V44.148H327.862V39.648H340.222V44.928C341.602 42.588 344.482 39.648 350.482 39.648H355.582V44.448H349.942C342.562 44.448 340.342 49.968 340.342 54.828V65.748H353.902V70.248H327.862ZM375.209 70.608C368.489 70.608 363.929 67.248 363.929 61.668C363.929 55.548 368.189 52.128 376.229 52.128H385.229V50.028C385.229 46.068 382.409 43.668 377.609 43.668C373.289 43.668 370.409 45.708 369.809 48.828H364.889C365.609 42.828 370.469 39.288 377.849 39.288C385.649 39.288 390.149 43.188 390.149 50.328V63.708C390.149 65.328 390.749 65.748 392.129 65.748H393.689V70.248H390.989C386.909 70.248 385.529 68.508 385.469 65.508C383.549 68.268 380.489 70.608 375.209 70.608ZM375.569 66.408C381.689 66.408 385.229 62.868 385.229 57.768V56.268H375.749C371.369 56.268 368.909 57.888 368.909 61.368C368.909 64.368 371.489 66.408 375.569 66.408ZM401.076 82.248V39.648H405.336L405.996 44.568C408.036 41.748 411.336 39.288 416.496 39.288C424.956 39.288 431.196 44.988 431.196 54.948C431.196 64.308 424.956 70.608 416.496 70.608C411.336 70.608 407.856 68.508 405.996 65.568V82.248H401.076ZM416.016 66.228C422.076 66.228 426.156 61.608 426.156 54.948C426.156 48.288 422.076 43.668 416.016 43.668C410.016 43.668 405.936 48.288 405.936 54.828C405.936 61.548 410.016 66.228 416.016 66.228ZM439.663 70.248V28.248H444.583V43.788C446.863 40.968 450.403 39.288 454.363 39.288C462.043 39.288 466.423 44.388 466.423 53.208V70.248H461.503V53.508C461.503 47.268 458.623 43.788 453.523 43.788C448.063 43.788 444.583 48.108 444.583 54.948V70.248H439.663Z" fill="white"/>
-</svg>

.github/images/logo-light.svg

@@ -1,5 +0,0 @@
-<svg width="472" height="100" viewBox="0 0 472 100" fill="none" xmlns="http://www.w3.org/2000/svg">
-<rect x="100" width="100" height="100" rx="20" transform="rotate(90 100 0)" fill="#161F34"/>
-<path d="M32.1494 67.8578H45.2266C45.2246 75.0776 39.3716 80.9299 32.1514 80.9301C24.9301 80.9299 19.0756 75.0761 19.0752 67.8549C19.0752 60.634 24.9288 54.7799 32.1494 54.7787V67.8578ZM67.8691 54.7787C75.0906 54.7789 80.9443 60.6334 80.9443 67.8549C80.944 75.076 75.0904 80.9299 67.8691 80.9301C60.6488 80.9299 54.7949 75.0777 54.793 67.8578H67.8594V54.7787C67.8626 54.7787 67.8659 54.7787 67.8691 54.7787ZM67.8691 19.0756C75.0906 19.0758 80.9443 24.9303 80.9443 32.1517C80.944 39.373 75.0904 45.2267 67.8691 45.2269C67.8659 45.2269 67.8626 45.226 67.8594 45.226V32.1478H54.793C54.795 24.928 60.6489 19.0757 67.8691 19.0756ZM32.1514 19.0756C39.3716 19.0757 45.2246 24.928 45.2266 32.1478H32.1494V45.226C24.929 45.2248 19.0755 39.3724 19.0752 32.1517C19.0752 24.9302 24.9299 19.0757 32.1514 19.0756Z" fill="#7FC8FF"/>
-<path d="M142.427 70.248V65.748H153.227V32.748H142.427V28.248H158.147V65.748H168.947V70.248H142.427ZM189.174 70.608C182.454 70.608 177.894 67.248 177.894 61.668C177.894 55.548 182.154 52.128 190.194 52.128H199.194V50.028C199.194 46.068 196.374 43.668 191.574 43.668C187.254 43.668 184.374 45.708 183.774 48.828H178.854C179.574 42.828 184.434 39.288 191.814 39.288C199.614 39.288 204.114 43.188 204.114 50.328V63.708C204.114 65.328 204.714 65.748 206.094 65.748H207.654V70.248H204.954C200.874 70.248 199.494 68.508 199.434 65.508C197.514 68.268 194.454 70.608 189.174 70.608ZM189.534 66.408C195.654 66.408 199.194 62.868 199.194 57.768V56.268H189.714C185.334 56.268 182.874 57.888 182.874 61.368C182.874 64.368 185.454 66.408 189.534 66.408ZM216.601 70.248V39.648H220.861L221.521 43.788C223.321 41.448 226.321 39.288 231.121 39.288C237.601 39.288 243.001 42.948 243.001 52.848V70.248H238.081V53.148C238.081 47.028 235.201 43.788 230.281 43.788C224.941 43.788 221.521 47.928 221.521 53.988V70.248H216.601ZM266.348 82.608C258.548 82.608 253.088 78.948 252.308 72.228H257.348C258.188 76.068 261.608 78.228 266.708 78.228C273.128 78.228 276.608 75.228 276.608 68.568V64.968C274.568 68.448 271.268 70.608 266.108 70.608C257.648 70.608 251.408 64.908 251.408 54.948C251.408 45.588 257.648 39.288 266.108 39.288C271.268 39.288 274.688 41.508 276.608 44.928L277.268 39.648H281.528V68.748C281.528 77.568 276.848 82.608 266.348 82.608ZM266.588 66.228C272.588 66.228 276.668 61.608 276.668 55.068C276.668 48.348 272.588 43.668 266.588 43.668C260.528 43.668 256.448 48.288 256.448 54.948C256.448 61.608 260.528 66.228 266.588 66.228ZM303.555 82.608C295.755 82.608 290.295 78.948 289.515 72.228H294.555C295.395 76.068 298.815 78.228 303.915 78.228C310.335 78.228 313.815 75.228 313.815 68.568V64.968C311.775 68.448 308.475 70.608 303.315 70.608C294.855 70.608 288.615 64.908 288.615 54.948C288.615 45.588 294.855 39.288 303.315 39.288C308.475 39.288 311.895 41.508 313.815 44.928L314.475 39.648H318.735V68.748C318.735 77.568 314.055 82.608 303.555 82.608ZM303.795 66.228C309.795 66.228 313.875 61.608 313.875 55.068C313.875 48.348 309.795 43.668 303.795 43.668C297.735 43.668 293.655 48.288 293.655 54.948C293.655 61.608 297.735 66.228 303.795 66.228ZM327.862 70.248V65.748H335.422V44.148H327.862V39.648H340.222V44.928C341.602 42.588 344.482 39.648 350.482 39.648H355.582V44.448H349.942C342.562 44.448 340.342 49.968 340.342 54.828V65.748H353.902V70.248H327.862ZM375.209 70.608C368.489 70.608 363.929 67.248 363.929 61.668C363.929 55.548 368.189 52.128 376.229 52.128H385.229V50.028C385.229 46.068 382.409 43.668 377.609 43.668C373.289 43.668 370.409 45.708 369.809 48.828H364.889C365.609 42.828 370.469 39.288 377.849 39.288C385.649 39.288 390.149 43.188 390.149 50.328V63.708C390.149 65.328 390.749 65.748 392.129 65.748H393.689V70.248H390.989C386.909 70.248 385.529 68.508 385.469 65.508C383.549 68.268 380.489 70.608 375.209 70.608ZM375.569 66.408C381.689 66.408 385.229 62.868 385.229 57.768V56.268H375.749C371.369 56.268 368.909 57.888 368.909 61.368C368.909 64.368 371.489 66.408 375.569 66.408ZM401.076 82.248V39.648H405.336L405.996 44.568C408.036 41.748 411.336 39.288 416.496 39.288C424.956 39.288 431.196 44.988 431.196 54.948C431.196 64.308 424.956 70.608 416.496 70.608C411.336 70.608 407.856 68.508 405.996 65.568V82.248H401.076ZM416.016 66.228C422.076 66.228 426.156 61.608 426.156 54.948C426.156 48.288 422.076 43.668 416.016 43.668C410.016 43.668 405.936 48.288 405.936 54.828C405.936 61.548 410.016 66.228 416.016 66.228ZM439.663 70.248V28.248H444.583V43.788C446.863 40.968 450.403 39.288 454.363 39.288C462.043 39.288 466.423 44.388 466.423 53.208V70.248H461.503V53.508C461.503 47.268 458.623 43.788 453.523 43.788C448.063 43.788 444.583 48.108 444.583 54.948V70.248H439.663Z" fill="#161F34"/>
-</svg>

.github/scripts/check_sdk_methods.py

@@ -1,15 +1,10 @@
 import ast
 import os
 from itertools import filterfalse
-from typing import Dict, List, Tuple
+from typing import List, Tuple
 
 ROOT_PATH = os.path.abspath(os.path.join(__file__, "..", "..", ".."))
 CLIENT_PATH = os.path.join(ROOT_PATH, "libs", "sdk-py", "langgraph_sdk", "client.py")
-ASYNC_TO_SYNC_METHOD_MAP: Dict[str, str] = {
-    "aclose": "close",
-    "__aenter__": "__enter__",
-    "__aexit__": "__exit__",
-}
 
 
 def get_class_methods(node: ast.ClassDef) -> List[str]:
@@ -27,7 +22,7 @@ def find_classes(tree: ast.AST) -> List[Tuple[str, List[str]]]:
 
 def compare_sync_async_methods(sync_methods: List[str], async_methods: List[str]) -> List[str]:
     sync_set = set(sync_methods)
-    async_set = {ASYNC_TO_SYNC_METHOD_MAP.get(async_method, async_method) for async_method in async_methods}
+    async_set = set(async_methods)
     missing_in_sync = list(async_set - sync_set)
     missing_in_async = list(sync_set - async_set)
     return missing_in_sync + missing_in_async
@@ -38,7 +33,7 @@ def main():
         tree = ast.parse(file.read())
 
     classes = find_classes(tree)
-
+  
     def is_sync(class_spec: Tuple[str, List[str]]) -> bool:
         return class_spec[0].startswith("Sync")
 

.github/scripts/run_langgraph_cli_test.py

@@ -1,164 +1,108 @@
-import logging
+import asyncio
+import json
+import os
 import pathlib
 import sys
-import time
-from urllib import error, request
-
 import langgraph_cli
-import langgraph_cli.config
 import langgraph_cli.docker
-from langgraph_cli.cli import prepare_args_and_stdin
-from langgraph_cli.constants import DEFAULT_PORT
+import langgraph_cli.config
+
 from langgraph_cli.exec import Runner, subp_exec
 from langgraph_cli.progress import Progress
-
-logger = logging.getLogger(__name__)
-logging.basicConfig(level=logging.INFO)
+from langgraph_cli.constants import DEFAULT_PORT
 
 
-def test(config: pathlib.Path, port: int, tag: str, verbose: bool):
-    """Spin up API with Postgres/Redis via docker compose and wait until ready."""
-    logger.info("Starting test...")
+def test(
+    config: pathlib.Path,
+    port: int,
+    tag: str,
+    verbose: bool,
+):
     with Runner() as runner, Progress(message="Pulling...") as set:
-        # Detect docker/compose capabilities
+        # check docker available
         capabilities = langgraph_cli.docker.check_capabilities(runner)
-
-        # Validate config and prepare compose stdin/args using built image
+        # open config
         config_json = langgraph_cli.config.validate_config_file(config)
-        args, stdin = prepare_args_and_stdin(
-            capabilities=capabilities,
-            config_path=config,
-            config=config_json,
-            docker_compose=None,
-            port=port,
-            watch=False,
-            debugger_port=None,
-            debugger_base_url=f"http://127.0.0.1:{port}",
-            postgres_uri=None,
-            api_version=None,
-            image=tag,
-            base_image=None,
-        )
 
-        # Compose up with wait (implies detach), similar to `langgraph up --wait`
-        args_up = [*args, "up", "--remove-orphans", "--wait"]
-
-        compose_cmd = ["docker", "compose"]
-        if capabilities.compose_type == "standalone":
-            compose_cmd = ["docker-compose"]
-
-        set("Starting...")
-        try:
-            runner.run(
-                subp_exec(
-                    *compose_cmd,
-                    *args_up,
-                    input=stdin,
-                    verbose=verbose,
-                )
+        set("Running...")
+        args = [
+            "run",
+            "--rm",
+            "-p",
+            f"{port}:8000",
+        ]
+        if isinstance(config_json["env"], str):
+            args.extend(
+                [
+                    "--env-file",
+                    str(config.parent / config_json["env"]),
+                ]
             )
-        except Exception as e:  # noqa: BLE001
-            # On failure, show diagnostics then ensure clean teardown
-            sys.stderr.write(f"docker compose up failed: {e}\n")
-            try:
-                sys.stderr.write("\n== docker compose ps ==\n")
-                runner.run(
-                    subp_exec(*compose_cmd, *args, "ps", input=stdin, verbose=True)
-                )
-            except Exception:
-                pass
-            try:
-                sys.stderr.write("\n== docker compose logs (api) ==\n")
-                runner.run(
-                    subp_exec(
-                        *compose_cmd,
-                        *args,
-                        "logs",
-                        "langgraph-api",
-                        input=stdin,
-                        verbose=True,
-                    )
-                )
-            except Exception:
-                pass
-            finally:
-                try:
-                    runner.run(
-                        subp_exec(
-                            *compose_cmd,
-                            *args,
-                            "down",
-                            "-v",
-                            "--remove-orphans",
-                            input=stdin,
-                            verbose=False,
-                        )
-                    )
-                finally:
-                    raise
-
-        set("")
-        base_url = f"http://localhost:{port}"
-        ok_url = f"{base_url}/ok"
-        logger.info(f"Waiting for {ok_url} to respond with 200...")
-        deadline = time.time() + 30
-        last_err: Exception | None = None
-        while time.time() < deadline:
-            try:
-                with request.urlopen(ok_url, timeout=2) as resp:
-                    if resp.status == 200:
-                        sys.stdout.write(
-                            f"""Ready!\n- API: {base_url}\n- /ok: 200 OK\n"""
-                        )
-                        sys.stdout.flush()
-                        break
-                    else:
-                        last_err = RuntimeError(f"Unexpected status: {resp.status}")
-                        logger.error(f"Unexpected status: {resp.status}")
-            except error.URLError as e:
-                logger.error(f"URLError: {e}")
-                last_err = e
-            except Exception as e:  # noqa: BLE001
-                logger.error(f"Exception: {e}")
-                last_err = e
-            time.sleep(0.5)
         else:
-            logger.error("Timeout waiting for /ok to return 200")
-            # Bring stack down before raising
-            args_down = [*args, "down", "-v", "--remove-orphans"]
-            try:
-                runner.run(
-                    subp_exec(
-                        *compose_cmd,
-                        *args_down,
-                        input=stdin,
-                        verbose=verbose,
-                    )
-                )
-            finally:
-                raise SystemExit(
-                    f"/ok did not return 202 within timeout. Last error: {last_err}"
+            for k, v in config_json["env"].items():
+                args.extend(
+                    [
+                        "-e",
+                        f"{k}={v}",
+                    ]
                 )
+        if capabilities.healthcheck_start_interval:
+            args.extend(
+                [
+                    "--health-interval",
+                    "5s",
+                    "--health-retries",
+                    "1",
+                    "--health-start-period",
+                    "10s",
+                    "--health-start-interval",
+                    "1s",
+                ]
+            )
+        else:
+            args.extend(
+                [
+                    "--health-interval",
+                    "5s",
+                    "--health-retries",
+                    "2",
+                ]
+            )
+
+        _task = None
+
+        def on_stdout(line: str):
+            nonlocal _task
+            if "GET /ok" in line or "Uvicorn running on" in line:
+                set("")
+                sys.stdout.write(
+                    f"""Ready!
+- API: http://localhost:{port}
+"""
+                )
+                sys.stdout.flush()
+                _task.cancel()
+                return True
+            return False
+
+        async def subp_exec_task(*args, **kwargs):
+            nonlocal _task
+            _task = asyncio.create_task(subp_exec(*args, **kwargs))
+            await _task
 
-        # Clean up: bring compose stack down to free ports for next test
-        logger.info("Test succeeded. Bringing down compose stack...")
         try:
-            args_down = [*args, "down", "-v", "--remove-orphans"]
             runner.run(
-                subp_exec(
-                    *compose_cmd,
-                    *args_down,
-                    input=stdin,
+                subp_exec_task(
+                    "docker",
+                    *args,
+                    tag,
                     verbose=verbose,
+                    on_stdout=on_stdout,
                 )
             )
-            logger.info("Compose stack down. Finishing...")
-        except Exception:
-            logger.exception("Failed to bring down compose stack")
+        except asyncio.CancelledError:
             pass
 
-    logger.info("Test finished")
-
 
 if __name__ == "__main__":
     import argparse
@@ -166,12 +110,6 @@ if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-t", "--tag", type=str)
     parser.add_argument("-c", "--config", type=str, default="./langgraph.json")
-    parser.add_argument("-p", "--port", type=int, default=DEFAULT_PORT)
+    parser.add_argument("-p", "--port", default=DEFAULT_PORT)
     args = parser.parse_args()
-    try:
-        test(pathlib.Path(args.config), args.port, args.tag, verbose=True)
-    except BaseException:
-        logger.exception("Test failed")
-        raise
-    
-    logger.info("Test execution finished")
+    test(pathlib.Path(args.config), args.port, args.tag, verbose=True)

.github/workflows/_integration_test.yml

@@ -2,12 +2,9 @@ name: CLI integration test
 
 on:
   workflow_call:
-    secrets:
-      LANGSMITH_API_KEY:
-        required: false
 
-permissions:
-  contents: read
+env:
+  POETRY_VERSION: "1.7.1"
 
 jobs:
   build:
@@ -16,124 +13,62 @@ jobs:
       matrix:
         python-version:
           - "3.10"
-          - "3.14"
-        example:
-          - name: A
-            workdir: libs/cli/examples
-            tag: langgraph-test-a
-          - name: B
-            workdir: libs/cli/examples/graphs
-            tag: langgraph-test-b
-          - name: C
-            workdir: libs/cli/examples/graphs_reqs_a
-            tag: langgraph-test-c
-          - name: D
-            workdir: libs/cli/examples/graphs_reqs_b
-            tag: langgraph-test-d
+          - "3.11"
     name: "CLI integration test"
-    env:
-      HAS_LANGSMITH_API_KEY: ${{ secrets.LANGSMITH_API_KEY != '' }}
     defaults:
       run:
         working-directory: libs/cli
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
       - name: Get changed files
         id: changed-files
-        if: github.event_name != 'workflow_dispatch'
         uses: Ana06/get-changed-files@v2.3.0
         with:
           filter: "libs/cli/**"
-      - name: Set up Python ${{ matrix.python-version }}
-        if: (steps.changed-files.outputs.all || github.event_name == 'workflow_dispatch')
-        uses: astral-sh/setup-uv@v7
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        if: steps.changed-files.outputs.all
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ matrix.python-version }}
-          enable-cache: true
-          cache-suffix: "cli-integration-test"
-          ignore-nothing-to-cache: true
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: integration-test-cli
+      - name: Setup env
+        if: steps.changed-files.outputs.all
+        working-directory: libs/cli/examples
+        run: cat .env.example > .env
       - name: Install cli globally
-        if: (steps.changed-files.outputs.all || github.event_name == 'workflow_dispatch')
+        if: steps.changed-files.outputs.all
         run: pip install -e .
-      - name: Build service ${{ matrix.example.name }}
-        if: (steps.changed-files.outputs.all || github.event_name == 'workflow_dispatch')
-        working-directory: ${{ matrix.example.workdir }}
+      - name: Build and test service A
+        if: steps.changed-files.outputs.all
+        working-directory: libs/cli/examples
         run: |
-          langgraph build -t ${{ matrix.example.tag }}
-      - name: Test service ${{ matrix.example.name }}
-        if: ${{ (steps.changed-files.outputs.all || github.event_name == 'workflow_dispatch') &&env.HAS_LANGSMITH_API_KEY == 'true' }}
-        working-directory: ${{ matrix.example.workdir }}
-        env:
-          LANGSMITH_API_KEY: ${{ secrets.LANGSMITH_API_KEY }}
+          # The build-arg isn't used; just testing that we accept other args
+          langgraph build -t langgraph-test-a  --base-image "langchain/langgraph-trial"
+          cp .env.example .envg
+          timeout 60 python ../../../.github/scripts/run_langgraph_cli_test.py -c langgraph.json -t langgraph-test-a
+      - name: Build and test service B
+        if: steps.changed-files.outputs.all
+        working-directory: libs/cli/examples/graphs
         run: |
-          # Prepare environment file from local or parent example directory
-          if [ -f .env.example ]; then cp .env.example .env; elif [ -f ../.env.example ]; then cp ../.env.example .env && cp ../.env.example ../.env; fi
-          echo "LANGSMITH_API_KEY=${{ secrets.LANGSMITH_API_KEY }}" >> .env
-          if [ -f ../.env ]; then echo "LANGSMITH_API_KEY=${{ secrets.LANGSMITH_API_KEY }}" >> ../.env; fi
-          # Run the integration test using the built tag
-          REPO_ROOT=$(git rev-parse --show-toplevel)
-          timeout 60 python "$REPO_ROOT/.github/scripts/run_langgraph_cli_test.py" -t ${{ matrix.example.tag }}
+          langgraph build -t langgraph-test-b  --base-image "langchain/langgraph-trial"
+          timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-b
+      - name: Build and test service C
+        if: steps.changed-files.outputs.all
+        working-directory: libs/cli/examples/graphs_reqs_a
+        run: |
+          langgraph build -t langgraph-test-c  --base-image "langchain/langgraph-trial"
+          timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-c
+      - name: Build and test service D
+        if: steps.changed-files.outputs.all
+        working-directory: libs/cli/examples/graphs_reqs_b
+        run: |
+          langgraph build -t langgraph-test-d  --base-image "langchain/langgraph-trial"
+          timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-d
 
       - name: Build JS service
-        if: ${{ (steps.changed-files.outputs.all || github.event_name == 'workflow_dispatch') &&matrix.example.name == 'A' }}
+        if: steps.changed-files.outputs.all
         working-directory: libs/cli/js-examples
         run: |
           langgraph build -t langgraph-test-e
-
-      - name: Build JS monorepo service
-        if: ${{ (steps.changed-files.outputs.all || github.event_name == 'workflow_dispatch') &&matrix.example.name == 'A' }}
-        working-directory: libs/cli/js-monorepo-example
-        run: |
-          langgraph build -t langgraph-test-f -c apps/agent/langgraph.json --build-command "yarn run turbo build" --install-command "yarn install"
-
-      - name: Build Python monorepo service
-        if: ${{ (steps.changed-files.outputs.all || github.event_name == 'workflow_dispatch') &&matrix.example.name == 'A' }}
-        working-directory: libs/cli/python-monorepo-example
-        run: |
-          langgraph build -t langgraph-test-g -c apps/agent/langgraph.json
-      - name: Test Python monorepo service
-        if: ${{ (steps.changed-files.outputs.all || github.event_name == 'workflow_dispatch') &&matrix.example.name == 'A' && env.HAS_LANGSMITH_API_KEY == 'true' }}
-        working-directory: libs/cli/python-monorepo-example
-        env:
-          LANGSMITH_API_KEY: ${{ secrets.LANGSMITH_API_KEY }}
-        run: |
-          cp apps/agent/.env.example apps/agent/.env
-          echo "LANGSMITH_API_KEY=${{ secrets.LANGSMITH_API_KEY }}" >> apps/agent/.env
-          timeout 60 python ../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-g -c apps/agent/langgraph.json
-
-      - name: Build prerelease reqs service
-        if: ${{ (steps.changed-files.outputs.all || github.event_name == 'workflow_dispatch') &&matrix.example.name == 'A' }}
-        working-directory: libs/cli/examples/graph_prerelease_reqs
-        run: |
-          langgraph build -t langgraph-test-h
-      - name: Test prerelease reqs service
-        if: ${{ (steps.changed-files.outputs.all || github.event_name == 'workflow_dispatch') &&matrix.example.name == 'A' && env.HAS_LANGSMITH_API_KEY == 'true' }}
-        working-directory: libs/cli/examples/graph_prerelease_reqs
-        env:
-          LANGSMITH_API_KEY: ${{ secrets.LANGSMITH_API_KEY }}
-        run: |
-          cp ../.env.example .env
-          echo "LANGSMITH_API_KEY=${{ secrets.LANGSMITH_API_KEY }}" >> .env
-          timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-h
-          echo "Finished starting up langgraph-test-h"
-          LANGGRAPH_VERSION=$(docker run --rm --entrypoint "" langgraph-test-h python -c "import sys; from importlib.metadata import version; v = version('langgraph'); print(v);")
-          if [ "$LANGGRAPH_VERSION" != "1.0.8" ]; then
-            echo "LANGGRAPH_VERSION != 1.0.8; $LANGGRAPH_VERSION"
-            exit 1
-          fi
-          LANGCHAIN_OPENAI_VERSION=$(docker run --rm --entrypoint "" langgraph-test-h python -c "import sys; from importlib.metadata import version; v = version('langchain-openai'); print(v);")
-          if [ "$LANGCHAIN_OPENAI_VERSION" != "1.0.1" ]; then
-            echo "LANGCHAIN_OPENAI_VERSION != 1.0.1; $LANGCHAIN_OPENAI_VERSION"
-            exit 1
-          fi
-          LANGCHAIN_ANTHROPIC_VERSION=$(docker run --rm --entrypoint "" langgraph-test-h python -c "import sys; from importlib.metadata import version; v = version('langchain-anthropic'); print(v);")
-          if [ "$LANGCHAIN_ANTHROPIC_VERSION" != "1.0.0a5" ]; then
-            echo "LANGCHAIN_ANTHROPIC_VERSION != 1.0.0a5; $LANGCHAIN_ANTHROPIC_VERSION"
-            exit 1
-          fi
-
-      - name: Build and test prerelease reqs fail service
-        if: ${{ (steps.changed-files.outputs.all || github.event_name == 'workflow_dispatch') &&matrix.example.name == 'A' }}
-        working-directory: libs/cli/examples/graph_prerelease_reqs_fail
-        run: |
-          langgraph build -t langgraph-test-i || [ $? -eq 1 ]
+  

.github/workflows/_lint.yml

@@ -8,10 +8,9 @@ on:
         type: string
         description: "From which folder this pipeline executes"
 
-permissions:
-  contents: read
-
 env:
+  POETRY_VERSION: "1.7.1"
+
   # This env var allows us to get inline annotations when ruff has complaints.
   RUFF_OUTPUT_FORMAT: github
 
@@ -31,38 +30,57 @@ jobs:
           - "3.12"
     name: "lint #${{ matrix.python-version }}"
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
       - name: Get changed files
         id: changed-files
-        if: github.event_name != 'workflow_dispatch'
         uses: Ana06/get-changed-files@v2.3.0
         with:
           filter: "${{ inputs.working-directory }}/**"
-      - name: Set up Python ${{ matrix.python-version }}
-        if: steps.changed-files.outputs.all || github.event_name == 'workflow_dispatch'
-        uses: astral-sh/setup-uv@v7
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        if: steps.changed-files.outputs.all
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ matrix.python-version }}
-          enable-cache: true
-          cache-suffix: lint-${{ inputs.working-directory }}
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: lint-${{ inputs.working-directory }}
+
+      - name: Check Poetry File
+        if: steps.changed-files.outputs.all
+        shell: bash
+        working-directory: ${{ inputs.working-directory }}
+        run: poetry check
+
+      - name: Check lock file
+        if: steps.changed-files.outputs.all
+        shell: bash
+        working-directory: ${{ inputs.working-directory }}
+        run: poetry lock --check
 
       - name: Install dependencies
-        if: steps.changed-files.outputs.all || github.event_name == 'workflow_dispatch'
+        if: steps.changed-files.outputs.all
+        # Also installs dev/lint/test/typing dependencies, to ensure we have
+        # type hints for as many of our libraries as possible.
+        # This helps catch errors that require dependencies to be spotted, for example:
+        # https://github.com/langchain-ai/langchain/pull/10249/files#diff-935185cd488d015f026dcd9e19616ff62863e8cde8c0bee70318d3ccbca98341
+        #
+        # If you change this configuration, make sure to change the `cache-key`
+        # in the `poetry_setup` action above to stop using the old cache.
+        # It doesn't matter how you change it, any change will cause a cache-bust.
         working-directory: ${{ inputs.working-directory }}
-        run: uv sync --frozen --group lint
+        run: poetry install --with dev
 
       - name: Get .mypy_cache to speed up mypy
-        if: steps.changed-files.outputs.all || github.event_name == 'workflow_dispatch'
-        uses: actions/cache@v5
+        if: steps.changed-files.outputs.all
+        uses: actions/cache@v3
         env:
           SEGMENT_DOWNLOAD_TIMEOUT_MIN: "2"
         with:
           path: |
             ${{ inputs.working-directory }}/.mypy_cache
-          key: mypy-lint-${{ runner.os }}-${{ runner.arch }}-py${{ matrix.python-version }}-${{ inputs.working-directory }}-${{ hashFiles(format('{0}/uv.lock', inputs.working-directory)) }}
+          key: mypy-lint-${{ runner.os }}-${{ runner.arch }}-py${{ matrix.python-version }}-${{ inputs.working-directory }}-${{ hashFiles(format('{0}/poetry.lock', inputs.working-directory)) }}
 
       - name: Analysing package code with our lint
-        if: steps.changed-files.outputs.all || github.event_name == 'workflow_dispatch'
+        if: steps.changed-files.outputs.all
         working-directory: ${{ inputs.working-directory }}
         run: |
           if make lint_package > /dev/null 2>&1; then
@@ -73,22 +91,31 @@ jobs:
           fi
 
       - name: Install test dependencies
-        if: steps.changed-files.outputs.all || github.event_name == 'workflow_dispatch'
+        if: steps.changed-files.outputs.all
+        # Also installs dev/lint/test/typing dependencies, to ensure we have
+        # type hints for as many of our libraries as possible.
+        # This helps catch errors that require dependencies to be spotted, for example:
+        # https://github.com/langchain-ai/langchain/pull/10249/files#diff-935185cd488d015f026dcd9e19616ff62863e8cde8c0bee70318d3ccbca98341
+        #
+        # If you change this configuration, make sure to change the `cache-key`
+        # in the `poetry_setup` action above to stop using the old cache.
+        # It doesn't matter how you change it, any change will cause a cache-bust.
         working-directory: ${{ inputs.working-directory }}
-        run: uv sync --group lint
+        run: |
+          poetry install --with dev
 
       - name: Get .mypy_cache_test to speed up mypy
-        if: steps.changed-files.outputs.all || github.event_name == 'workflow_dispatch'
-        uses: actions/cache@v5
+        if: steps.changed-files.outputs.all
+        uses: actions/cache@v3
         env:
           SEGMENT_DOWNLOAD_TIMEOUT_MIN: "2"
         with:
           path: |
             ${{ inputs.working-directory }}/.mypy_cache_test
-          key: mypy-test-${{ runner.os }}-${{ runner.arch }}-py${{ matrix.python-version }}-${{ inputs.working-directory }}-${{ hashFiles(format('{0}/uv.lock', inputs.working-directory)) }}
+          key: mypy-test-${{ runner.os }}-${{ runner.arch }}-py${{ matrix.python-version }}-${{ inputs.working-directory }}-${{ hashFiles(format('{0}/poetry.lock', inputs.working-directory)) }}
 
       - name: Analysing tests with our lint
-        if: steps.changed-files.outputs.all || github.event_name == 'workflow_dispatch'
+        if: steps.changed-files.outputs.all
         working-directory: ${{ inputs.working-directory }}
         run: |
           if make lint_tests > /dev/null 2>&1; then

.github/workflows/_test.yml

@@ -8,8 +8,8 @@ on:
         type: string
         description: "From which folder this pipeline executes"
 
-permissions:
-  contents: read
+env:
+  POETRY_VERSION: "1.7.1"
 
 jobs:
   build:
@@ -17,23 +17,23 @@ jobs:
     strategy:
       matrix:
         python-version:
+          - "3.9"
           - "3.10"
           - "3.11"
           - "3.12"
           - "3.13"
-          - "3.14"
 
     name: "test #${{ matrix.python-version }}"
     steps:
-      - uses: actions/checkout@v6
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: astral-sh/setup-uv@v7
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ matrix.python-version }}
-          enable-cache: true
-          cache-suffix: test-${{ inputs.working-directory }}
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: test-${{ inputs.working-directory }}
       - name: Login to Docker Hub
-        uses: docker/login-action@v4
+        uses: docker/login-action@v3
         if: ${{ !github.event.pull_request.head.repo.fork }}
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
@@ -42,12 +42,14 @@ jobs:
       - name: Install dependencies
         shell: bash
         working-directory: ${{ inputs.working-directory }}
-        run: uv sync --frozen --group test --no-dev
+        run: |
+          poetry install --with dev
 
       - name: Run tests
         shell: bash
         working-directory: ${{ inputs.working-directory }}
-        run: make test
+        run: |
+          make test
 
       - name: Ensure the tests did not create any additional files
         shell: bash

.github/workflows/_test_langgraph.yml

@@ -3,8 +3,8 @@ name: test
 on:
   workflow_call:
 
-permissions:
-  contents: read
+env:
+  POETRY_VERSION: "1.7.1"
 
 jobs:
   build:
@@ -12,26 +12,26 @@ jobs:
     strategy:
       matrix:
         python-version:
+          - "3.9"
           - "3.10"
           - "3.11"
           - "3.12"
           - "3.13"
-          - "3.14"
 
     defaults:
       run:
         working-directory: libs/langgraph
     name: "test #${{ matrix.python-version }}"
     steps:
-      - uses: actions/checkout@v6
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: astral-sh/setup-uv@v7
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ matrix.python-version }}
-          enable-cache: true
-          cache-suffix: "test-langgraph"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: test-langgraph
       - name: Login to Docker Hub
-        uses: docker/login-action@v4
+        uses: docker/login-action@v3
         if: ${{ !github.event.pull_request.head.repo.fork }}
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
@@ -39,18 +39,13 @@ jobs:
 
       - name: Install dependencies
         shell: bash
-        run: uv sync --frozen --group test --no-dev
+        run: |
+          poetry install --with dev
 
       - name: Run tests
         shell: bash
-        run: make test_parallel
-
-      - name: Run strict msgpack pregel tests
-        if: ${{ matrix.python-version == '3.13' }}
-        shell: bash
-        env:
-          LANGGRAPH_STRICT_MSGPACK: "true"
-        run: make test TEST="tests/test_pregel.py tests/test_pregel_async.py"
+        run: |
+          make test_parallel
 
       - name: Ensure the tests did not create any additional files
         shell: bash

.github/workflows/_test_release.yml

@@ -9,13 +9,12 @@ on:
         description: "From which folder this pipeline executes"
 
 env:
+  POETRY_VERSION: "1.7.1"
   PYTHON_VERSION: "3.10"
 
-permissions:
-  contents: read
-
 jobs:
   build:
+    if: github.ref == 'refs/heads/main'
     runs-on: ubuntu-latest
 
     outputs:
@@ -23,14 +22,14 @@ jobs:
       version: ${{ steps.check-version.outputs.version }}
 
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
 
-      - name: Set up Python $${ env.PYTHON_VERSION }}
-        uses: astral-sh/setup-uv@v7
+      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ env.PYTHON_VERSION }}
-          enable-cache: true
-          cache-suffix: "release"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: release
 
       # We want to keep this build stage *separate* from the release stage,
       # so that there's no sharing of permissions between them.
@@ -44,11 +43,11 @@ jobs:
       # > from the publish job.
       # https://github.com/pypa/gh-action-pypi-publish#non-goals
       - name: Build project for distribution
-        run: uv build
+        run: poetry build
         working-directory: ${{ inputs.working-directory }}
 
       - name: Upload build
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
         with:
           name: test-dist
           path: ${{ inputs.working-directory }}/dist/
@@ -58,8 +57,8 @@ jobs:
         shell: bash
         working-directory: ${{ inputs.working-directory }}
         run: |
-          echo pkg-name=$(grep -m 1 "^name = " pyproject.toml | cut -d '"' -f 2)
-          echo version=$(grep -m 1 "^version = " pyproject.toml | cut -d '"' -f 2)
+          echo pkg-name="$(poetry version | cut -d ' ' -f 1)" >> $GITHUB_OUTPUT
+          echo version="$(poetry version --short)" >> $GITHUB_OUTPUT
 
   publish:
     needs:
@@ -74,9 +73,9 @@ jobs:
       id-token: write
 
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
 
-      - uses: actions/download-artifact@v8
+      - uses: actions/download-artifact@v4
         with:
           name: test-dist
           path: ${{ inputs.working-directory }}/dist/

.github/workflows/_test_scheduler_kafka.yml

@@ -0,0 +1,57 @@
+name: test
+
+on:
+  workflow_call:
+
+env:
+  POETRY_VERSION: "1.7.1"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.11"
+          - "3.12"
+
+    defaults:
+      run:
+        working-directory: libs/scheduler-kafka
+    name: "test #${{ matrix.python-version }}"
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: ${{ matrix.python-version }}
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: test-scheduler-kafka
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        if: ${{ !github.event.pull_request.head.repo.fork }}
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_RO_TOKEN }}
+
+      - name: Install dependencies
+        shell: bash
+        run: |
+          poetry install --with dev
+
+      - name: Run tests
+        shell: bash
+        run: |
+          make test
+
+      - name: Ensure the tests did not create any additional files
+        shell: bash
+        run: |
+          set -eu
+
+          STATUS="$(git status)"
+          echo "$STATUS"
+
+          # grep will exit non-zero if the target message isn't found,
+          # and `set -e` above will cause the step to fail.
+          echo "$STATUS" | grep 'nothing to commit, working tree clean'

.github/workflows/baseline.yml

@@ -7,8 +7,8 @@ on:
     paths:
       - "libs/**"
 
-permissions:
-  contents: read
+env:
+  POETRY_VERSION: "1.7.1"
 
 jobs:
   benchmark:
@@ -17,20 +17,20 @@ jobs:
       run:
         working-directory: libs/langgraph
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
       - run: SHA=$(git rev-parse HEAD) && echo "SHA=$SHA" >> $GITHUB_ENV
-      - name: Set up Python 3.11
-        uses: astral-sh/setup-uv@v7
+      - name: Set up Python 3.11 + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: "3.11"
-          enable-cache: true
-          cache-suffix: "bench"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: bench
       - name: Install dependencies
-        run: uv sync --group test
+        run: poetry install --with dev
       - name: Run benchmarks
         run: OUTPUT=out/benchmark-baseline.json make -s benchmark
       - name: Save outputs
-        uses: actions/cache/save@v5
+        uses: actions/cache/save@v4
         with:
           key: ${{ runner.os }}-benchmark-baseline-${{ env.SHA }}
           path: |

.github/workflows/bench.yml

@@ -5,8 +5,8 @@ on:
     paths:
       - "libs/**"
 
-permissions:
-  contents: read
+env:
+  POETRY_VERSION: "1.7.1"
 
 jobs:
   benchmark:
@@ -15,22 +15,22 @@ jobs:
       run:
         working-directory: libs/langgraph
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
       - id: files
         name: Get changed files
         uses: Ana06/get-changed-files@v2.3.0
         with:
           format: json
-      - name: Set up Python 3.11
-        uses: astral-sh/setup-uv@v7
+      - name: Set up Python 3.11 + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: "3.11"
-          enable-cache: true
-          cache-suffix: "bench"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: bench
       - name: Install dependencies
-        run: uv sync --group test
+        run: poetry install --with dev
       - name: Download baseline
-        uses: actions/cache/restore@v5
+        uses: actions/cache/restore@v4
         with:
           key: ${{ runner.os }}-benchmark-baseline
           restore-keys: |
@@ -43,7 +43,7 @@ jobs:
         run: |
           {
             echo 'OUTPUT<<EOF'
-            make -s benchmark-fast
+            make -s benchmark
             echo EOF
           } >> "$GITHUB_OUTPUT"
       - name: Compare benchmarks
@@ -53,11 +53,11 @@ jobs:
             echo 'OUTPUT<<EOF'
             mv out/benchmark-baseline.json out/main.json
             mv out/benchmark.json out/changes.json
-            uv run pyperf compare_to out/main.json out/changes.json --table --group-by-speed
+            poetry run pyperf compare_to out/main.json out/changes.json --table --group-by-speed
             echo EOF
           } >> "$GITHUB_OUTPUT"
       - name: Annotation
-        uses: actions/github-script@v8
+        uses: actions/github-script@v7
         with:
           script: |
             const file = JSON.parse(`${{ steps.files.outputs.added_modified_renamed }}`)[0]

.github/workflows/ci.yml

@@ -2,15 +2,9 @@
 name: CI
 
 on:
-  workflow_dispatch:
   push:
-    branches:
-      - main
+    branches: [main]
   pull_request:
-  
-
-permissions:
-  contents: read
 
 # If another push to the same PR or branch happens while this workflow is still running,
 # cancel the earlier run in favor of the next run.
@@ -22,16 +16,18 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
+env:
+  POETRY_VERSION: "1.7.1"
+
 jobs:
   changes:
     runs-on: ubuntu-latest
     outputs:
-      python: ${{ steps.filter.outputs.python || 'true' }}
-      deps: ${{ steps.filter.outputs.deps || 'true' }}
+      python: ${{ steps.filter.outputs.python }}
+      sdk-js: ${{ steps.filter.outputs.sdk-js }}
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
       - uses: dorny/paths-filter@v3
-        if: github.event_name != 'workflow_dispatch'
         id: filter
         with:
           filters: |
@@ -42,11 +38,10 @@ jobs:
               - 'libs/checkpoint/**'
               - 'libs/checkpoint-sqlite/**'
               - 'libs/checkpoint-postgres/**'
-              - 'libs/checkpoint-conformance/**'
+              - 'libs/scheduler-kafka/**'
               - 'libs/prebuilt/**'
-            deps:
-              - '**/pyproject.toml'
-              - '**/uv.lock'
+            sdk-js:
+              - 'libs/sdk-js/**'
 
   lint:
     needs: changes
@@ -61,10 +56,10 @@ jobs:
             "libs/checkpoint",
             "libs/checkpoint-sqlite",
             "libs/checkpoint-postgres",
-            "libs/checkpoint-conformance",
+            "libs/scheduler-kafka",
             "libs/prebuilt",
           ]
-    if: needs.changes.outputs.python == 'true' || needs.changes.outputs.deps == 'true'
+    if: needs.changes.outputs.python == 'true'
     uses: ./.github/workflows/_lint.yml
     with:
       working-directory: ${{ matrix.working-directory }}
@@ -81,11 +76,9 @@ jobs:
             "libs/checkpoint",
             "libs/checkpoint-sqlite",
             "libs/checkpoint-postgres",
-            "libs/checkpoint-conformance",
             "libs/prebuilt",
-            "libs/sdk-py",
           ]
-    if: needs.changes.outputs.python == 'true' || needs.changes.outputs.deps == 'true'
+    if: needs.changes.outputs.python == 'true'
     uses: ./.github/workflows/_test.yml
     with:
       working-directory: ${{ matrix.working-directory }}
@@ -94,78 +87,101 @@ jobs:
   # NOTE: we're testing langgraph separately because it requires a different matrix
   test-langgraph:
     needs: changes
-    if: needs.changes.outputs.python == 'true' || needs.changes.outputs.deps == 'true'
+    if: needs.changes.outputs.python == 'true'
     name: "cd libs/langgraph"
     uses: ./.github/workflows/_test_langgraph.yml
     secrets: inherit
 
+  # NOTE: we're testing scheduler-kafka separately because it requires a different matrix
+  test-scheduler-kafka:
+    needs: changes
+    if: needs.changes.outputs.python == 'true'
+    name: "cd libs/scheduler-kafka"
+    uses: ./.github/workflows/_test_scheduler_kafka.yml
+    secrets: inherit
+
   check-sdk-methods:
     needs: changes
     if: needs.changes.outputs.python == 'true'
     name: "Check SDK methods matching"
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
       - name: Set up Python
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@v5
         with:
           python-version: "3.11"
       - 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.13"
-    steps:
-      - uses: actions/checkout@v6
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: astral-sh/setup-uv@v7
-        with:
-          python-version: "3.13"
-          enable-cache: true
-          cache-suffix: "schema-check-cli"
-      - name: Install CLI dependencies
-        run: |
-          cd libs/cli
-          uv sync
-      - 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
-          uv 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 'uv 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' || needs.changes.outputs.deps == 'true'
+    if: needs.changes.outputs.python == 'true'
     name: CLI integration test
     uses: ./.github/workflows/_integration_test.yml
     secrets: inherit
 
+  lint-js:
+    needs: changes
+    if: needs.changes.outputs.sdk-js == 'true'
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        working-directory:
+          - "libs/sdk-js"
+    defaults:
+      run:
+        working-directory: ${{ matrix.working-directory }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Node.js (LTS)
+        uses: actions/setup-node@v3
+        with:
+          node-version: "20"
+          cache: "yarn"
+          cache-dependency-path: ${{ matrix.working-directory }}/yarn.lock
+      - name: Install dependencies
+        run: yarn install
+      - name: Run lint
+        run: yarn lint
+      - name: Build
+        run: yarn build
+
+  test-js:
+    needs: changes
+    if: needs.changes.outputs.sdk-js == 'true'
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        working-directory:
+          - "libs/sdk-js"
+    defaults:
+      run:
+        working-directory: ${{ matrix.working-directory }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Node.js (LTS)
+        uses: actions/setup-node@v3
+        with:
+          node-version: "20"
+          cache: "yarn"
+          cache-dependency-path: ${{ matrix.working-directory }}/yarn.lock
+      - name: Install dependencies
+        run: yarn install
+      - name: Run tests
+        run: yarn test
+
   ci_success:
     name: "CI Success"
     needs:
       [
         lint,
+        lint-js,
         test,
         test-langgraph,
-        check-sdk-methods,
-        check-schema,
+        test-scheduler-kafka,
         integration-test,
+        test-js,
       ]
     if: |
       always()

.github/workflows/codespell.yml

@@ -0,0 +1,43 @@
+---
+    name: CI / cd . / make spell_check
+    
+    on:
+      push:
+        branches: [main]
+      pull_request:
+        branches: [main]
+    
+    permissions:
+      contents: read
+
+    defaults:
+      run:
+        working-directory: docs
+
+    jobs:
+      codespell:
+        name: (Check for spelling errors)
+        runs-on: ubuntu-latest
+    
+        steps:
+          - name: Checkout
+            uses: actions/checkout@v4
+    
+          - name: Install Dependencies
+            run: |
+              pip install toml codespell==2.3.0 jupytext
+    
+          - name: Extract Ignore Words List
+            run: |
+              # Use a Python script to extract the ignore words list from pyproject.toml
+              python ../.github/workflows/extract_ignored_words_list.py
+            id: extract_ignore_words
+    
+          - name: Codespell
+            uses: codespell-project/actions-codespell@v2
+            with:
+              skip: '*.ambr,*.lock,*.ipynb,*.yaml,*.zlib,*.md'
+              ignore_words_list: ${{ steps.extract_ignore_words.outputs.ignore_words_list }}
+          # We do this to avoid spellchecking cell outputs
+          - name: Codespell Notebooks
+            run: make codespell

.github/workflows/deploy-redirects.yml

@@ -1,49 +0,0 @@
-name: Deploy Redirects to GitHub Pages
-
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - 'docs/**'
-      - '.github/workflows/deploy-redirects.yml'
-  workflow_dispatch:
-
-permissions:
-  contents: read
-  pages: write
-  id-token: write
-
-concurrency:
-  group: "pages"
-  cancel-in-progress: false
-
-jobs:
-  deploy:
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-
-      - name: Setup Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: '3.11'
-
-      - name: Generate redirect files
-        run: python docs/generate_redirects.py
-
-      - name: Setup Pages
-        uses: actions/configure-pages@v5
-
-      - name: Upload artifact
-        uses: actions/upload-pages-artifact@v4
-        with:
-          path: 'docs/_site'
-
-      - name: Deploy to GitHub Pages
-        id: deployment
-        uses: actions/deploy-pages@v4

.github/workflows/deploy_docs.yml

@@ -0,0 +1,170 @@
+name: Deploy Docs
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+  workflow_dispatch:
+
+env:
+  POETRY_VERSION: "1.7.1"
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+defaults:
+  run:
+    working-directory: docs
+
+jobs:
+  get-changed-files:
+    runs-on: ubuntu-latest
+    outputs:
+      changed-files: ${{ steps.changed-files.outputs.added_modified }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Get changed files
+        id: changed-files
+        uses: Ana06/get-changed-files@v2.3.0
+        with:
+          filter: "docs/docs/**"
+
+  run-changed-notebooks:
+    needs: get-changed-files
+    uses: ./.github/workflows/run_notebooks.yml
+    secrets: inherit
+    with:
+      changed-files: ${{ needs.get-changed-files.outputs.changed-files }}
+
+  deploy:
+    # needs: run-changed-notebooks
+    runs-on: ubuntu-latest
+    timeout-minutes: 10 # Job will be cancelled if it runs for more than 10 minutes
+    env:
+      GITHUB_TOKEN: ${{ secrets.MKDOCS_GITHUB_TOKEN }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: "3.12"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: docs
+
+      - name: Use Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: "22"
+          cache: "yarn"
+          cache-dependency-path: docs/yarn.lock
+
+      - name: Install dependencies
+        run: |
+          yarn
+          poetry install --with test --with docs --no-root
+          poetry run pip install -U \
+            pytest \
+            pytest-check-links \
+            GitPython \
+            "git+https://github.com/benjamincburns/markdown-exec.git@cc0d39d737e5ffd4b83d23cd8729d7ea16e363c8"
+
+          # we run this installation only for internal PRs
+          # as GITHUB_TOKEN is not available for PRs from outside contributors
+          if [ -n "${GITHUB_TOKEN}" ]; then
+            poetry run pip install "git+https://${GITHUB_TOKEN}@github.com/langchain-ai/mkdocs-material-insiders.git"
+          fi
+
+          poetry run jupyter kernelspec list
+          poetry run python3 -m ipykernel install --user --name=python3
+          npm install -g tslab
+          poetry run tslab install --python=python3
+          poetry run jupyter kernelspec list
+
+      - name: Run unit tests
+        # Run unit tests on the docs build pipeline
+        run: make tests
+      - name: Lint Docs
+        # This step lints the docs using the existing linting set up.
+        # It should be very fast and should not require any external services.
+        run: make lint-docs
+      - name: Build llms-text
+        run: make llms-text
+      - name: Build site
+        run: make build-docs
+        env:
+          MKDOCS_GIT_COMMITTERS_APIKEY: ${{ secrets.MKDOCS_GIT_COMMITTERS_APIKEY }}
+          OPENAI_API_KEY: sf-proj-1234567890 # fake placeholder, shouldn't actually be used
+          ANTHROPIC_API_KEY: sk-ant-api03-1234567890 # fake placeholder, shouldn't actually be used
+      - name: Check links in notebooks
+        env:
+          LANGCHAIN_API_KEY: test
+        run: |
+          if [ "${{ github.event_name }}" == "schedule" ] || [ "${{ github.event_name }}" == "workflow_dispatch" ] || ([ "${{ github.event_name }}" == "push" ] && [ "${{ github.ref }}" == "refs/heads/main" ]); then
+            echo "Running link check on all HTML files matching notebooks in docs directory..."
+            poetry run pytest -v \
+              --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.*" \
+              --check-links-ignore "http://127.0.0.1:.*" \
+              --check-links-ignore "/.*\.(ipynb|html)$" \
+              --check-links-ignore "https://python\.langchain\.com/.*" \
+              --check-links-ignore "https://openai\.com/.*" \
+              --check-links-ignore "https://www\.uber\.com/.*" \
+              --check-links-ignore "https://pepy\.tech/.*" \
+              --check-links $(find site -name "index.html" | grep -v 'storm/index.html')
+              
+          else
+            echo "Fetching changes from origin/main..."
+            git fetch origin main
+            echo "Checking for changed notebook files..."
+            CHANGED_FILES=$(git diff --name-only --diff-filter=d origin/main | grep 'docs/docs/.*\.ipynb$' | grep -v 'storm.ipynb' | sed -E 's|^docs/docs/|site/|; s/\.ipynb$/\/index.html/' || true)
+            echo "Changed files: ${CHANGED_FILES}"
+            if [ -n "${CHANGED_FILES}" ]; then
+              echo "Running link check on HTML files matching changed notebook files..."
+              poetry run pytest -v \
+                --check-links-ignore "https://(api|web|docs)\.smith\.langchain\.com/.*" \
+                --check-links-ignore "https://academy\.langchain\.com/.*" \
+                --check-links-ignore "http://localhost:8123/.*" \
+                --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} \
+                || ([ $? = 5 ] && exit 0 || exit $?)
+            else
+              echo "No notebook files changed."
+            fi
+          fi
+
+      - name: Configure GitHub Pages
+        if: github.ref == 'refs/heads/main'
+        uses: actions/configure-pages@v4
+
+      - name: Upload Pages Artifact
+        # if: github.ref == 'refs/heads/main'
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: ./docs/site/
+
+      - name: Deploy to GitHub Pages
+        if: github.ref == 'refs/heads/main'
+        id: deployment
+        uses: actions/deploy-pages@v4

.github/workflows/extract_ignored_words_list.py

@@ -0,0 +1,10 @@
+import toml
+
+pyproject_toml = toml.load("pyproject.toml")
+
+# Extract the ignore words list (adjust the key as per your TOML structure)
+ignore_words_list = (
+    pyproject_toml.get("tool", {}).get("codespell", {}).get("ignore-words-list")
+)
+
+print(f"::set-output name=ignore_words_list::{ignore_words_list}")  # noqa: T201

.github/workflows/link_check.yml

@@ -0,0 +1,49 @@
+name: Check Docs & Links
+
+on:
+  pull_request:
+    branches:
+      - main
+  push:
+    branches:
+      - main
+  schedule:
+    - cron: "0 5 * * *"
+  workflow_dispatch:
+
+env:
+  POETRY_VERSION: "1.7.1"
+
+jobs:
+  markdown-link-check:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Check links in Markdown files
+        uses: gaurav-nelson/github-action-markdown-link-check@v1
+        with:
+          folder-path: "docs/"
+          check-modified-files-only: ${{ github.event_name != 'schedule' }}
+          file-path: "./README.md"
+          config-file: "./.markdown-link-check.config.json"
+
+  check-readmes-synced:
+    # This checks that the repo README.md is identical to the libs/langgraph/README.md
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Check README.md is in sync
+        run: |
+            if ! diff -q README.md libs/langgraph/README.md >/dev/null; then
+            echo "README.md is out of sync with libs/langgraph/README.md"
+            diff -C 3 README.md libs/langgraph/README.md
+            exit 1
+            fi

.github/workflows/pr_lint.yml

@@ -1,46 +0,0 @@
-name: PR Title Lint
-
-permissions:
-  pull-requests: read
-
-on:
-  pull_request:
-    types: [opened, edited, synchronize]
-
-jobs:
-  lint-pr-title:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Validate PR Title
-        uses: amannn/action-semantic-pull-request@v6
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          types: |
-            feat
-            fix
-            docs
-            style
-            refactor
-            perf
-            test
-            build
-            ci
-            chore
-            revert
-            release
-          scopes: |
-            checkpoint
-            checkpoint-postgres
-            checkpoint-sqlite
-            cli
-            langgraph
-            prebuilt
-            scheduler-kafka
-            sdk-py
-            docs
-            ci
-            deps
-          requireScope: false
-          ignoreLabels: |
-            ignore-lint-pr-title

.github/workflows/release.yml

@@ -8,14 +8,13 @@ on:
         type: string
         default: "libs/langgraph"
 
-permissions:
-  contents: read
-
 env:
   PYTHON_VERSION: "3.11"
+  POETRY_VERSION: "1.7.1"
 
 jobs:
   build:
+    if: github.ref == 'refs/heads/main'
     runs-on: ubuntu-latest
 
     outputs:
@@ -25,14 +24,14 @@ jobs:
       tag: ${{ steps.check-version.outputs.tag }}
 
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
 
-      - name: Set up Python
-        uses: astral-sh/setup-uv@v7
+      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ env.PYTHON_VERSION }}
-          enable-cache: true
-          cache-suffix: "release"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: release
 
       # We want to keep this build stage *separate* from the release stage,
       # so that there's no sharing of permissions between them.
@@ -46,11 +45,11 @@ jobs:
       # > from the publish job.
       # https://github.com/pypa/gh-action-pypi-publish#non-goals
       - name: Build project for distribution
-        run: uv build
+        run: poetry build
         working-directory: ${{ inputs.working-directory }}
 
       - name: Upload build
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
         with:
           name: dist
           path: ${{ inputs.working-directory }}/dist/
@@ -60,14 +59,8 @@ jobs:
         shell: bash
         working-directory: ${{ inputs.working-directory }}
         run: |
-          PKG_NAME=$(grep -m 1 "^name = " pyproject.toml | cut -d '"' -f 2)
-          if grep -q 'dynamic.*=.*\[.*"version".*\]' pyproject.toml; then
-            # handle dynamic versioning
-            DIR_NAME=$(echo "$PKG_NAME" | tr '-' '_')
-            VERSION=$(grep -m 1 '^__version__' "${DIR_NAME}/__init__.py" | cut -d '"' -f 2)
-          else
-            VERSION=$(grep -m 1 "^version = " pyproject.toml | cut -d '"' -f 2)
-          fi
+          PKG_NAME="$(poetry version | cut -d ' ' -f 1)"
+          VERSION="$(poetry version --short)"
           SHORT_PKG_NAME="$(echo "$PKG_NAME" | sed -e 's/langgraph//g' -e 's/-//g')"
           if [ -z $SHORT_PKG_NAME ]; then
             TAG="$VERSION"
@@ -86,7 +79,7 @@ jobs:
     outputs:
       release-body: ${{ steps.generate-release-body.outputs.release-body }}
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
         with:
           repository: langchain-ai/langgraph
           path: langgraph
@@ -142,9 +135,7 @@ jobs:
     needs:
       - build
       - release-notes
-    permissions:
-      contents: read
-      id-token: write
+    permissions: write-all
     uses: ./.github/workflows/_test_release.yml
     with:
       working-directory: ${{ inputs.working-directory }}
@@ -157,7 +148,7 @@ jobs:
       - test-pypi-publish
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
 
       # We explicitly *don't* set up caching here. This ensures our tests are
       # maximally sensitive to catching breakage.
@@ -172,11 +163,11 @@ jobs:
       # - The package is published, and it breaks on the missing dependency when
       #   used in the real world.
 
-      - name: Set up Python
-        uses: astral-sh/setup-uv@v7
+      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ env.PYTHON_VERSION }}
-          enable-cache: true
+          poetry-version: ${{ env.POETRY_VERSION }}
 
       - name: Import published package
         shell: bash
@@ -194,18 +185,18 @@ jobs:
         # - attempt install again after 5 seconds if it fails because there is
         #   sometimes a delay in availability on test pypi
         run: |
-          uv run pip install \
+          poetry run pip install \
             --extra-index-url https://test.pypi.org/simple/ \
             "$PKG_NAME==$VERSION" || \
           ( \
             sleep 5 && \
-            uv run pip install \
+            poetry run pip install \
               --extra-index-url https://test.pypi.org/simple/ \
               "$PKG_NAME==$VERSION" \
           )
 
           if [[ "$PKG_NAME" == *prebuilt* ]]; then
-            uv run pip install langgraph
+            poetry run pip install langgraph
           fi
 
           if [[ "$PKG_NAME" == *checkpoint* || "$PKG_NAME" == *prebuilt* ]]; then
@@ -218,10 +209,10 @@ jobs:
             IMPORT_NAME="$(echo "$PKG_NAME" | sed s/-/_/g)"
           fi
 
-          uv run python -c "import $IMPORT_NAME; print(dir($IMPORT_NAME))"
+          poetry run python -c "import $IMPORT_NAME; print(dir($IMPORT_NAME))"
 
       - name: Import test dependencies
-        run: uv sync --group test
+        run: poetry install --with dev
         working-directory: ${{ inputs.working-directory }}
 
       # Overwrite the local version of the package with the test PyPI version.
@@ -232,7 +223,7 @@ jobs:
           PKG_NAME: ${{ needs.build.outputs.pkg-name }}
           VERSION: ${{ needs.build.outputs.version }}
         run: |
-          uv run pip install \
+          poetry run pip install \
             --extra-index-url https://test.pypi.org/simple/ \
             "$PKG_NAME==$VERSION"
 
@@ -260,16 +251,16 @@ jobs:
         working-directory: ${{ inputs.working-directory }}
 
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
 
-      - name: Set up Python
-        uses: astral-sh/setup-uv@v7
+      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ env.PYTHON_VERSION }}
-          enable-cache: true
-          cache-suffix: "release"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: release
 
-      - uses: actions/download-artifact@v8
+      - uses: actions/download-artifact@v4
         with:
           name: dist
           path: ${{ inputs.working-directory }}/dist/
@@ -301,16 +292,16 @@ jobs:
         working-directory: ${{ inputs.working-directory }}
 
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
 
-      - name: Set up Python
-        uses: astral-sh/setup-uv@v7
+      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ env.PYTHON_VERSION }}
-          enable-cache: true
-          cache-suffix: "release"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: release
 
-      - uses: actions/download-artifact@v8
+      - uses: actions/download-artifact@v4
         with:
           name: dist
           path: ${{ inputs.working-directory }}/dist/
@@ -322,6 +313,5 @@ jobs:
           token: ${{ secrets.GITHUB_TOKEN }}
           generateReleaseNotes: false
           tag: ${{needs.build.outputs.tag}}
-          name: ${{ needs.build.outputs.pkg-name }}==${{ needs.build.outputs.version }}
           body: ${{ needs.release-notes.outputs.release-body }}
           commit: ${{ github.sha }}

.github/workflows/release_js.yml

@@ -0,0 +1,38 @@
+name: JS Release
+
+on:
+  workflow_dispatch:
+
+jobs:
+  publish:
+    # Disallow publishing from branches that aren't `main`.
+    if: github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        working-directory:
+          - "libs/sdk-js"
+
+    defaults:
+      run:
+        working-directory: ${{ matrix.working-directory }}
+
+    steps:
+      - uses: actions/checkout@v4
+      # JS Build
+      - name: Use Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: "20"
+          cache: "yarn"
+          cache-dependency-path: ${{ matrix.working-directory }}/yarn.lock
+
+      - name: Install dependencies
+        run: yarn install
+      - name: Build
+        run: yarn build
+      - name: Publish package to NPM
+        run: |
+          echo "//registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}" > .npmrc
+          npm publish

.github/workflows/run_notebooks.yml

@@ -0,0 +1,82 @@
+name: Run notebooks
+
+on:
+  workflow_dispatch:
+  workflow_call:
+    inputs:
+      changed-files:
+        required: false
+        type: string
+        description: "JSON string of changed files"
+  schedule:
+    - cron: '0 13 * * *'
+
+defaults:
+  run:
+    working-directory: docs
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        lib-version:
+          - "development"
+          - "latest"
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python + Poetry
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: 3.11
+          poetry-version: 1.7.1
+          cache-key: test-langgraph-notebooks
+
+      - name: Install dependencies
+        run: |
+          poetry install --with test
+          poetry run pip install jupyter
+
+      - name: Start services
+        run: make start-services
+
+      - name: Pre-download tiktoken files
+        run: |
+          poetry run python _scripts/download_tiktoken.py
+
+      - name: Prepare notebooks
+        run: |
+          if [ "${{ matrix.lib-version }}" = "development" ]; then
+            poetry run python _scripts/prepare_notebooks_for_ci.py --comment-install-cells
+          else
+            poetry run python _scripts/prepare_notebooks_for_ci.py
+          fi
+
+      - name: Run notebooks
+        env:
+          # these won't actually be used because of the VCR cassettes
+          # but need to set them to avoid triggering getpass()
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          TAVILY_API_KEY: ${{ secrets.TAVILY_API_KEY }}
+          LANGSMITH_API_KEY: ${{ secrets.LANGSMITH_API_KEY }}
+          NOMIC_API_KEY: ${{ secrets.NOMIC_API_KEY }}
+          COHERE_API_KEY: ${{ secrets.COHERE_API_KEY }}
+          FIREWORKS_API_KEY: ${{ secrets.FIREWORKS_API_KEY }}
+        run: |
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ] || [ "${{ github.event_name }}" = "schedule" ]; then
+            echo "Running all notebooks"
+            ./_scripts/execute_notebooks.sh
+          else
+            CHANGED_FILES=$(echo '${{ inputs.changed-files }}' | tr ' ' '\n' | sed 's|^docs/docs/|docs/|' | grep '\.ipynb$' || true)
+            if [ -n "$CHANGED_FILES" ]; then
+              echo "Running changed notebooks: $CHANGED_FILES"
+              ./_scripts/execute_notebooks.sh $CHANGED_FILES
+            else
+              echo "No notebook files changed, skipping execution"
+            fi
+          fi
+
+      - name: Stop services
+        run: make stop-services

.github/workflows/size.yml

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

.github/workflows/uv_lock_ugprade.yml

@@ -1,45 +0,0 @@
-name: UV Lock Upgrade
-
-on:
-  schedule:
-    # run at midnight every Sunday
-    - cron: '0 0 * * 0'
-  # allow manual triggering
-  workflow_dispatch:
-
-permissions:
-  contents: write
-  pull-requests: write
-
-jobs:
-  upgrade-dependencies:
-    runs-on: ubuntu-latest
-    
-    steps:
-      - uses: actions/checkout@v6
-      
-      - name: Set up uv
-        uses: astral-sh/setup-uv@v7
-        with:
-          # use minimum supported Python version
-          python-version: "3.10"
-          enable-cache: true
-          cache-suffix: "uv-lock-upgrade"
-          
-      - name: Run uv lock --upgrade in all Python packages
-        run: make lock-upgrade
-          
-      - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v8
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          commit-message: "chore(deps): upgrade dependencies with `uv lock --upgrade`"
-          title: "chore(deps): upgrade dependencies with `uv lock --upgrade`"
-          body: |
-            This PR updates the dependencies in all Python packages using `uv lock --upgrade`.
-            
-            This is an automated PR created by the UV Lock Upgrade workflow.
-          branch: deps/uv-lock-upgrade
-          delete-branch: true
-          labels: |
-            dependencies

.gitignore

@@ -6,6 +6,9 @@ __pycache__/
 *.py[cod]
 *$py.class
 
+# C extensions
+*.so
+
 # Distribution / packaging
 .Python
 build/
@@ -51,12 +54,27 @@ coverage.xml
 .hypothesis/
 .pytest_cache/
 
+# Translations
+*.mo
+*.pot
+
 # Django stuff:
 *.log
 local_settings.py
 db.sqlite3
 db.sqlite3-journal
 
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+docs/docs/_build/
+
 # PyBuilder
 target/
 
@@ -71,9 +89,23 @@ ipython_config.py
 # pyenv
 .python-version
 
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
 # PEP 582; used by e.g. github.com/David-OConnor/pyflow
 __pypackages__/
 
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
 # Environments
 .env
 .envrc
@@ -85,6 +117,16 @@ ENV/
 env.bak/
 venv.bak/
 
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
 # mypy
 .mypy_cache/
 .dmypy.json
@@ -96,14 +138,45 @@ dmypy.json
 # macOS display setting files
 .DS_Store
 
+# Wandb directory
+wandb/
+
+# asdf tool versions
+.tool-versions
+/.ruff_cache/
+
+*.pkl
+*.bin
+
+# integration test artifacts
+data_map*
+\[('_type', 'fake'), ('stop', None)]
+
+# Replit files
+*replit*
+
+node_modules
+docs/.yarn/
+docs/node_modules/
+docs/.docusaurus/
+docs/.cache-loader/
+docs/_dist
+docs/api_reference/api_reference.rst
+docs/api_reference/experimental_api_reference.rst
+docs/api_reference/_build
+docs/api_reference/*/
+!docs/api_reference/_static/
+!docs/api_reference/templates/
+!docs/api_reference/themes/
+docs/docs_skeleton/build
+docs/docs_skeleton/node_modules
+docs/docs_skeleton/yarn.lock
+
+# Any new jupyter notebooks
+# not intended for the repo
+Untitled*.ipynb
+
+Chinook.db
+
 .vercel
 .turbo
-.editorconfig
-.scratch
-
-# macOS debug symbol bundles generated during local Rust builds
-saf-python-sdk/python/saf_python_sdk/*.dSYM/
-
-# Local PyO3 extension artifacts for saf-python-sdk
-saf-python-sdk/python/saf_python_sdk/langgraph_rust_core*.so
-saf-python-sdk/python/saf_python_sdk/langgraph_rust_core*.pyd

.markdown-link-check.config.json

@@ -0,0 +1,4 @@
+{
+  "aliveStatusCodes": [200, 206, 402],
+  "ignorePatterns": ["*dcbadge.vercel.app*"]
+}

AGENTS.md

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

CLAUDE.md

@@ -1,57 +1,142 @@
-# AGENTS Instructions
+# LangGraph Coding Guide
 
-This repository is a monorepo. Each library lives in a subdirectory under `libs/`.
+## Repository Structure
 
-When you modify code in any library, run the following commands in that library's directory before creating a pull request:
+LangGraph follows a monorepo organization, with the following structure:
 
-- `make format` – run code formatters
-- `make lint` – run the linter
-- `make test` – execute the test suite
+- `libs/langgraph` is the main Python library, published to pypi as `langgraph`. This contains the majority of the code for the framework, as well as the majority of the unit tests.
+- `libs/checkpoint` , published to pypi as `langgraph-checkpoint` contains the base classes for the persistence layer of langgraph. The two main abstractions are BaseCheckpointSaver (base class for persistence of workflow runs step-by-step) and BaseStore (base class for "long-term memory" operations, offering a key-value interface combined with semantic search over documents, used for persisting information across distinct workflow runs). This library is a dependency of both the main langgraph library, as well as implementations of these storage interfaces for specific databases. This library also contains reference implementations
+- `libs/checkpoint-postgres` published to pypi as langgraph-checkpoint-postgres, contains implementations of checkpoint and store backed by postgres. Majority of the test coverage is in `libs/langgraph` in the form of tests that run over all storage implementations in the repo.
+- `langgraph-java` contains a Java implementation of the langgraph framework, which is in the early stages of development.
 
-To run a particular test file or to pass additional pytest options you can specify the `TEST` variable:
+## Feature Overview
 
-```
-TEST=path/to/test.py make test
-```
+langgraph is an orchestration framework (in the style of airflow or temporal) designed for LLM applications, with a focus on streaming output, cyclical and parallel workflows, and interrupt/resume capabilities. Applications built with langgraph are variously called workflows, graphs, cognitive architectures, agents. Key features:
 
-Other pytest arguments can also be supplied inside the `TEST` variable.
+1. **Graph-based Architecture**: Build directed computation graphs with nodes and edges
+2. **State Management**: Type-safe state schema with custom reducers and transformations
+3. **Human-in-the-loop**: Support for interrupts, checkpoints, and tool call review
+4. **Persistence**: Save and resume execution with in-memory or database storage
+5. **Streaming**: Multiple modes (values, updates, custom) for real-time feedback
+6. **Multi-agent Patterns**: Support for network, supervisor, and hierarchical architectures
 
-## Libraries
+## Python Development
 
-The repository contains several Python and JavaScript/TypeScript libraries.
-Below is a high-level overview:
+### Build/Test/Lint Commands
 
-- **checkpoint** – base interfaces for LangGraph checkpointers.
-- **checkpoint-postgres** – Postgres implementation of the checkpoint saver.
-- **checkpoint-sqlite** – SQLite implementation of the checkpoint saver.
-- **cli** – official command-line interface for LangGraph.
-- **langgraph** – core framework for building stateful, multi-actor agents.
-- **prebuilt** – high-level APIs for creating and running agents and tools.
-- **sdk-js** – JS/TS SDK for interacting with the LangGraph REST API.
-- **sdk-py** – Python SDK for the LangGraph Server API.
+(in the respective subdirectory)
 
-### Dependency map
+- Run all tests: `make test`
+- Run single test: `make test TEST=path/to/test_file.py::test_function`
+- Watch mode tests: `make test_watch`
+- Run tests in parallel: `make test_parallel`
+- Generate coverage report: `make coverage`
+- Format code: `make format`
+- Lint code: `make lint`
+- Check spelling: `make spell_check`
+- Fix spelling: `make spell_fix`
+- Build documentation: `make serve-docs` (from repo root)
+- Run benchmarks: `make benchmark` or `make benchmark-fast`
 
-The diagram below lists downstream libraries for each production dependency as
-declared in that library's `pyproject.toml` (or `package.json`).
+### Code Style Guidelines
 
-```text
-checkpoint
-├── checkpoint-postgres
-├── checkpoint-sqlite
-├── prebuilt
-└── langgraph
+- Follow [ruff](https://github.com/astral-sh/ruff) formatting/linting rules
+- Use [Google Python Style Guide](https://google.github.io/styleguide/pyguide.html) for docstrings
+- Enforce type annotations with mypy (`disallow_untyped_defs = True`)
+- Use double quotes for strings
+- Maximum line length of 88 characters
+- Follow imports sorting with `ruff`
+- All functions/classes must have proper docstrings with args/returns
+- Write comprehensive unit tests for new features
+- Keep backward compatibility
+- PR scope should be isolated (changes shouldn't affect multiple packages)
+- Use descriptive variable names following Python conventions
+- Error handling should use appropriate exception types and messaging
 
-prebuilt
-└── langgraph
+## Java Development
 
-sdk-py
-├── langgraph
-└── cli
+(in the `langgraph-java` subdirectory)
 
-sdk-js (standalone)
-```
+### Build/Test/Lint Commands
 
-Changes to a library may impact all of its dependents shown above.
+- Build the project: `./gradlew build`
+- Run tests: `./gradlew test`
+- Run a specific test: `./gradlew test --tests "com.langgraph.package.TestClass.testMethod"`
+- Check formatting: `./gradlew spotlessCheck`
+- Apply formatting: `./gradlew spotlessApply`
+- Run all checks: `./gradlew check`
+- Generate Javadoc: `./gradlew javadoc`
 
-- Do NOT use Sphinx-style double backtick formatting (` ``code`` `). Use single backticks (`` `code` ``) for inline code references in docstrings and comments.
+### Code Style Guidelines
+
+- Follow standard Java code style (Google Java Style Guide)
+- Use 4 spaces for indentation
+- Maximum line length of 100 characters
+- All public methods/classes must have proper Javadoc with @param/@return tags
+- Use descriptive variable names following Java conventions (camelCase)
+- Exception handling should use appropriate exception types with descriptive messages
+- Favor composition over inheritance
+- Use the Builder pattern for complex object creation
+- Write comprehensive unit tests for new features
+
+### Python Compatibility Guidelines
+
+- When implementing features from the Python version:
+  - Maintain semantic equivalence with the Python implementation
+  - Preserve the same behavior for all public APIs
+  - Document any intentional differences in behavior with comments
+  - Pay special attention to collections handling (Python lists vs Java Lists)
+  - Ensure that iteration order and value handling match Python where relevant
+- Use the same test cases as the Python version when possible
+- Do not introduce Java-specific shortcuts that would break Python compatibility
+- Never add test-specific code to source files - tests should adapt to implementation, not vice versa
+
+### Implementation Mapping
+
+- Always consult and update the `PYTHON_JAVA_MAPPING.md` file when:
+  - Adding new Java files or classes
+  - Updating existing Java implementations
+  - Fixing test failures in Java
+  - Implementing Python features in Java
+- This mapping file documents:
+  - Where to find equivalent functionality in Python and Java
+  - Any intentional deviations between implementations
+  - Implementation status and compatibility notes
+- When tests fail, check if the Java implementation matches Python behavior:
+  - Fix the implementation to match Python semantics whenever possible
+  - Update tests only if the Python version also differs
+  - Never create special cases or workarounds in Java just to make tests pass
+  - Document any implementation differences clearly in the mapping file
+- For new features, implement the Python behavior first, then adapt to Java idioms
+
+### Backward Compatibility and API Design
+
+- LangGraph Java has not been released publicly, so there is no need to maintain backward compatibility
+- When renaming methods, members, or classes:
+  - Use the clearest, most intuitive names that match Python semantics
+  - Remove old/deprecated methods completely rather than marking them as deprecated
+  - Update all tests and documentation to use the new names
+  - Do not leave deprecated methods or tests for backward compatibility
+
+### API Design Principles
+
+- Prefer a single, clear way to accomplish each task rather than multiple convenience methods
+- Prefer builder patterns over static factory methods where appropriate
+- For collections, prefer methods that operate on collections rather than having both single-item and collection variants
+- Choose method names that clearly express their purpose and align with Java conventions
+- Maintain consistent naming patterns across similar components
+- Document the recommended usage pattern in JavaDoc
+
+### Project Structure
+
+- `langgraph-core`: Core functionality of the framework
+- `langgraph-checkpoint`: Persistence layer for checkpoints and state management
+- `langgraph-examples`: Example applications and usage patterns
+
+### Error Handling
+
+- Use runtime exceptions for unexpected errors
+- Use checked exceptions for recoverable errors
+- Provide clear error messages that include context about what went wrong
+- Validate inputs early to prevent cascading errors
+- Ensure all resources are properly closed even in error conditions

CONTRIBUTING.md

@@ -0,0 +1,293 @@
+# Contributing to LangGraph
+
+Thank you for being interested in contributing to LangGraph!
+
+## General guidelines
+
+Here are some things to keep in mind for all types of contributions:
+
+- Follow the ["fork and pull request"](https://docs.github.com/en/get-started/exploring-projects-on-github/contributing-to-a-project) workflow.
+- Fill out the checked-in pull request template when opening pull requests. Note related issues and tag relevant maintainers.
+- Ensure your PR passes formatting, linting, and testing checks before requesting a review.
+  - If you would like comments or feedback, please open an issue or discussion and tag a maintainer.
+- Backwards compatibility is key. Your changes must not be breaking, except in case of critical bug and security fixes.
+- Look for duplicate PRs or issues that have already been opened before opening a new one.
+- Keep scope as isolated as possible. As a general rule, your changes should not affect more than one package at a time.
+
+### Bugfixes
+
+For bug fixes, please open up an issue before proposing a fix to ensure the proposal properly addresses the underlying problem. In general, bug fixes should all have an accompanying unit test that fails before the fix.
+
+### New features
+
+For new features, please start a new [discussion](https://github.com/langchain-ai/langgraph/discussions), where the maintainers will help with scoping out the necessary changes.
+
+## Contribute Documentation
+
+Documentation is a vital part of LangGraph. We welcome both new documentation for new features and
+community improvements to our current documentation. Please read the resources below before getting started:
+
+- [Documentation style guide](#documentation-style-guide)
+- [Documentation setup](#setup)
+
+## Documentation Style Guide
+
+As LangGraph continues to grow, the surface area of documentation required to cover it continues to grow too.
+This page provides guidelines for anyone writing documentation for LangGraph, as well as some of our philosophies around organization and structure.
+
+## Philosophy
+
+LangGraph's documentation follows the [Diataxis framework](https://diataxis.fr).
+Under this framework, all documentation falls under one of four categories: [Tutorials](#tutorials),
+[How-to guides](#how-to-guides),
+[References](#references), and [Explanations (aka conceptual guides)](#conceptual-guide).
+
+### Tutorials
+
+Tutorials are lessons that take the reader through a practical activity. Their purpose is to help the user
+gain understanding of concepts and how they interact by showing one way to achieve some goal in a hands-on way.
+
+They should **avoid** giving
+multiple permutations of ways to achieve that goal in-depth. Choice is burdensome. Instead, they should guide a new user through a recommended path to accomplishing a concrete goal. While the end result of a tutorial does not necessarily need to
+be completely production-ready, it should be useful and practically satisfy the goal that you clearly stated in the tutorial's introduction.
+
+To quote the Diataxis website:
+
+> A tutorial serves the user’s *acquisition* of skills and knowledge - their study. Its purpose is not to help the user get something done, but to help them learn.
+
+In LangGraph, these are often higher level guides that show off end-to-end use cases.
+
+Some examples include:
+
+- [Build a Customer Support Bot](https://langchain-ai.github.io/langgraph/tutorials/customer-support/customer-support/)
+- [Build a SQL Agent](https://langchain-ai.github.io/langgraph/tutorials/sql-agent/)
+
+Here are some high-level tips on writing a good tutorial:
+
+- Focus on guiding the user to get something done, but keep in mind the end-goal is more to impart principles than to create a perfect production system.
+- Be specific, not abstract and follow one path.
+  - No need to go deeply into alternative approaches, but it’s ok to reference them, ideally with a link to an appropriate how-to guide.
+- Get "a point on the board" as soon as possible - something the user can run that outputs something.
+  - You can iterate and expand afterwards.
+  - Try to frequently checkpoint at given steps where the user can run code and see progress.
+- Focus on results, not technical explanation.
+  - Crosslink heavily to appropriate conceptual/reference pages
+- The first time you mention a LangGraph concept, use its full name (e.g. "human-in-the-loop"), and link to its conceptual/other documentation page.
+  - It's also helpful to add a prerequisite callout that links to any pages with necessary background information.
+- End with a recap/next steps section summarizing what the tutorial covered and future reading, such as related how-to guides.
+- Use phrases like "Next we can run X & Y. We will expect Z.". Then afterwards, use language like "Notice Z" that recalls our expectations and directs the reader's attention to the topic we are trying to teach.
+- Do not shy away from repetition.
+
+### How-to guides
+
+A how-to guide, as the name implies, demonstrates how to do something discrete and specific.
+It should assume that the user is already familiar with underlying concepts, and is trying to solve an immediate problem, but
+should still give some background or list the scenarios where the information contained within can be relevant.
+They can and should discuss alternatives if one approach may be better than another in certain cases.
+
+To quote the Diataxis website:
+
+> A how-to guide serves the work of the already-competent user, whom you can assume to know what they want to do, and to be able to follow your instructions correctly.
+
+Some examples include:
+
+- [How to add persistence to your graph](https://langchain-ai.github.io/langgraph/how-tos/persistence/)
+- [How to view and update past graph state](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/time-travel/)
+
+Here are some high-level tips on writing a good how-to guide:
+
+- Clearly explain what you are guiding the user through at the start
+- Assume higher intent than a tutorial and show what the user needs to do to get that task done
+- Assume familiarity of concepts, but explain why suggested actions are helpful
+  - Crosslink heavily to conceptual/reference pages
+- Discuss alternatives and responses to real-world tradeoffs that may arise when solving a problem
+- Use lots of example code, ideally within complete code blocks that the reader can copy and run.
+- End with a recap/next steps section summarizing what the tutorial covered and future reading, such as other related how-to guides
+
+### Conceptual guides
+
+LangGraph's conceptual guides fall under the **Explanation** quadrant of Diataxis. They should cover LangChain terms and concepts
+in a more abstract way than how-to guides or tutorials, and should be geared towards curious users interested in
+gaining a deeper understanding of the framework. Try to avoid excessively large code examples. The goal here is to
+impart perspective to the user rather than to finish a practical project. These guides should cover **why** things work they way they do.
+
+
+To quote the Diataxis website:
+
+> The perspective of explanation is higher and wider than that of the other types. It does not take the user’s eye-level view, as in a how-to guide, or a close-up view of the machinery, like reference material. Its scope in each case is a topic - “an area of knowledge”, that somehow has to be bounded in a reasonable, meaningful way.
+
+Some examples include:
+
+- [What does it mean to be agentic?](https://langchain-ai.github.io/langgraph/concepts/high_level/)
+- [Tool calling](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/#tool-calling)
+
+Here are some high-level tips on writing a good conceptual guide:
+
+- Explain design decisions. Why does concept X exist and why was it designed this way?
+- Use analogies and reference other concepts and alternatives
+- Avoid blending in too much reference content
+- You can and should reference content covered in other guides, but make sure to link to them
+
+### References
+
+References contain detailed, low-level information that describes exactly what functionality exists and how to use it.
+In LangGraph, this is mainly our API reference pages, which are populated from docstrings within code.
+References pages are generally not read end-to-end, but are consulted as necessary when a user needs to know
+how to use something specific.
+
+To quote the Diataxis website:
+
+> The only purpose of a reference guide is to describe, as succinctly as possible, and in an orderly way. Whereas the content of tutorials and how-to guides are led by needs of the user, reference material is led by the product it describes.
+
+Many of the reference pages in LangChain are automatically generated from code,
+but here are some high-level tips on writing a good docstring:
+
+- Be concise
+- Discuss special cases and deviations from a user's expectations
+- Go into detail on required inputs and outputs
+- Light details on when one might use the feature are fine, but in-depth details belong in other sections.
+
+Each category serves a distinct purpose and requires a specific approach to writing and structuring the content.
+
+## General guidelines
+
+Here are some other guidelines you should think about when writing and organizing documentation.
+
+We generally do not merge new tutorials from outside contributors without an actue need.
+We welcome updates as well as new integration docs, how-tos, and references.
+
+### Avoid duplication
+
+Multiple pages that cover the same material in depth are difficult to maintain and cause confusion. There should
+be only one (very rarely two), canonical pages for a given concept or feature. Instead, you should link to other guides.
+
+### Link to other sections
+
+Because sections of the docs do not exist in a vacuum, it is important to link to other sections as often as possible
+to allow a developer to learn more about an unfamiliar topic inline.
+
+This includes linking to the API references as well as conceptual sections!
+
+### Be concise
+
+In general, take a less-is-more approach. If a section with a good explanation of a concept already exists, you should link to it rather than
+re-explain it, unless the concept you are documenting presents some new wrinkle.
+
+Be concise, including in code samples.
+
+### General style
+
+- Use active voice and present tense whenever possible
+- Use examples and code snippets to illustrate concepts and usage
+- Use appropriate header levels (`#`, `##`, `###`, etc.) to organize the content hierarchically
+- Use fewer cells with more code to make copy/paste easier
+- Use bullet points and numbered lists to break down information into easily digestible chunks
+- Use tables (especially for **Reference** sections) and diagrams often to present information visually
+- Include the table of contents for longer documentation pages to help readers navigate the content, but hide it for shorter pages
+
+## Setup
+
+LangChain documentation consists of two components:
+
+1. Main Documentation: Hosted at [https://langchain-ai.github.io](https://langchain-ai.github.io/langgraph/),
+this comprehensive resource serves as the primary user-facing documentation.
+It covers a wide array of topics, including tutorials, use cases, integrations,
+and more, offering extensive guidance on building with LangGraph.
+The content for this documentation lives in the `/docs` directory of the monorepo.
+2. In-code Documentation: This is documentation of the codebase itself, which is also
+used to generate the externally facing [API Reference](https://langchain-ai.github.io/langgraph/reference/graphs/).
+The content for the API reference is autogenerated by scanning the docstrings in the codebase. For this reason we ask that developers document their code well.
+
+We appreciate all contributions to the documentation, whether it be fixing a typo,
+adding a new tutorial or example and whether it be in the main documentation or the API Reference.
+
+### 📜 Main Documentation
+
+The content for the main documentation is located in the `/docs` directory of the monorepo.
+
+The documentation is written using a combination of ipython notebooks (`.ipynb` files)
+and markdown (`.md` files). The notebooks are converted to markdown
+and then built using [MkDocs](https://www.mkdocs.org/).
+
+Feel free to make contributions to the main documentation! 🥰
+
+After modifying the documentation:
+
+1. Run the linting and formatting commands (see below) to ensure that the documentation is well-formatted and free of errors.
+2. Optionally build the documentation locally to verify that the changes look good.
+3. Make a pull request with the changes.
+
+### ⚒️ Linting and Building Documentation Locally
+
+After writing up the documentation, you may want to lint and build the documentation
+locally to ensure that it looks good and is free of errors.
+
+If you're unable to build it locally that's okay as well, as you will be able to
+see a preview of the documentation on the pull request page.
+
+From the **monorepo root**, run the following command to install the dependencies:
+
+```bash
+poetry install --with docs --no-root
+```
+
+#### Building
+
+The code that builds the documentation is located in the `/docs` directory of the monorepo.
+
+Before building the documentation, it is always a good idea to clean the build directory:
+
+```bash
+make clean-docs
+```
+
+You can build and preview the documentation as outlined below:
+
+```bash
+make serve-docs
+```
+
+#### Linting
+
+The documentation is linted from the **monorepo root**. To lint it, run the following from there:
+
+```bash
+make spellcheck
+```
+
+### ️In-code Documentation
+
+The in-code documentation is autogenerated from docstrings.
+
+For the API reference to be useful, the codebase must be well-documented. This means that all functions, classes, and methods should have a docstring that explains what they do, what the arguments are, and what the return value is. This is a good practice in general, but it is especially important for LangChain because the API reference is the primary resource for developers to understand how to use the codebase.
+
+We generally follow the [Google Python Style Guide](https://google.github.io/styleguide/pyguide.html#38-comments-and-docstrings) for docstrings.
+
+Here is an example of a well-documented function:
+
+```python
+
+def my_function(arg1: int, arg2: str) -> float:
+    """This is a short description of the function. (It should be a single sentence.)
+
+    This is a longer description of the function. It should explain what
+    the function does, what the arguments are, and what the return value is.
+    It should wrap at 88 characters.
+
+    Examples:
+        This is a section for examples of how to use the function.
+
+        .. code-block:: python
+
+            my_function(1, "hello")
+
+    Args:
+        arg1: This is a description of arg1. We do not need to specify the type since
+            it is already specified in the function signature.
+        arg2: This is a description of arg2.
+
+    Returns:
+        This is a description of the return value.
+    """
+    return 3.14
+```

Makefile

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

README.md

@@ -1,94 +1,339 @@
-<picture class="github-only">
-  <source media="(prefers-color-scheme: light)" srcset=".github/images/logo-light.svg">
-  <source media="(prefers-color-scheme: dark)" srcset=".github/images/logo-dark.svg">
-  <img alt="LangGraph Logo" src=".github/images/logo-dark.svg" width="50%">
-</picture>
+# 🦜🕸️LangGraph
 
-<div>
-<br>
-</div>
-
-[![Version](https://img.shields.io/pypi/v/langgraph.svg)](https://pypi.org/project/langgraph/)
+![Version](https://img.shields.io/pypi/v/langgraph)
 [![Downloads](https://static.pepy.tech/badge/langgraph/month)](https://pepy.tech/project/langgraph)
 [![Open Issues](https://img.shields.io/github/issues-raw/langchain-ai/langgraph)](https://github.com/langchain-ai/langgraph/issues)
-[![Docs](https://img.shields.io/badge/docs-latest-blue)](https://docs.langchain.com/oss/python/langgraph/overview)
+[![Docs](https://img.shields.io/badge/docs-latest-blue)](https://langchain-ai.github.io/langgraph/)
 
-Trusted by companies shaping the future of agents – including Klarna, Replit, Elastic, and more – LangGraph is a low-level orchestration framework for building, managing, and deploying long-running, stateful agents.
+⚡ Building language agents as graphs ⚡
 
-## Get started
+> [!NOTE]
+> Looking for the JS version? See the [JS repo](https://github.com/langchain-ai/langgraphjs) and the [JS docs](https://langchain-ai.github.io/langgraphjs/).
 
-Install LangGraph:
+## Overview
 
-```
+[LangGraph](https://langchain-ai.github.io/langgraph/) is a library for building
+stateful, multi-actor applications with LLMs, used to create agent and multi-agent
+workflows. Check out an introductory tutorial [here](https://langchain-ai.github.io/langgraph/tutorials/introduction/).
+
+
+LangGraph is inspired by [Pregel](https://research.google/pubs/pub37252/) and [Apache Beam](https://beam.apache.org/). The public interface draws inspiration from [NetworkX](https://networkx.org/documentation/latest/). LangGraph is built by LangChain Inc, the creators of LangChain, but can be used without LangChain.
+
+### Why use LangGraph?
+
+LangGraph powers [production-grade agents](https://www.langchain.com/built-with-langgraph), trusted by Linkedin, Uber, Klarna, GitLab, and many more. LangGraph provides fine-grained control over both the flow and state of your agent applications. It implements a central [persistence layer](https://langchain-ai.github.io/langgraph/concepts/persistence/), enabling features that are common to most agent architectures:
+
+- **Memory**: LangGraph persists arbitrary aspects of your application's state,
+supporting memory of conversations and other updates within and across user
+interactions;
+- **Human-in-the-loop**: Because state is checkpointed, execution can be interrupted
+and resumed, allowing for decisions, validation, and corrections at key stages via
+human input.
+
+Standardizing these components allows individuals and teams to focus on the behavior
+of their agent, instead of its supporting infrastructure.
+
+Through [LangGraph Platform](#langgraph-platform), LangGraph also provides tooling for
+the development, deployment, debugging, and monitoring of your applications.
+
+LangGraph integrates seamlessly with
+[LangChain](https://python.langchain.com/docs/introduction/) and
+[LangSmith](https://docs.smith.langchain.com/) (but does not require them).
+
+To learn more about LangGraph, check out our first LangChain Academy
+course, *Introduction to LangGraph*, available for free
+[here](https://academy.langchain.com/courses/intro-to-langgraph).
+
+### LangGraph Platform
+
+[LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/langgraph_platform) is infrastructure for deploying LangGraph agents. It is a commercial solution for deploying agentic applications to production, built on the open-source LangGraph framework. The LangGraph Platform consists of several components that work together to support the development, deployment, debugging, and monitoring of LangGraph applications: [LangGraph Server](https://langchain-ai.github.io/langgraph/concepts/langgraph_server) (APIs), [LangGraph SDKs](https://langchain-ai.github.io/langgraph/concepts/sdk) (clients for the APIs), [LangGraph CLI](https://langchain-ai.github.io/langgraph/concepts/langgraph_cli) (command line tool for building the server), and [LangGraph Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio) (UI/debugger).
+
+See deployment options [here](https://langchain-ai.github.io/langgraph/concepts/deployment_options/)
+(includes a free tier).
+
+Here are some common issues that arise in complex deployments, which LangGraph Platform addresses:
+
+- **Streaming support**: LangGraph Server provides [multiple streaming modes](https://langchain-ai.github.io/langgraph/concepts/streaming) optimized for various application needs
+- **Background runs**: Runs agents asynchronously in the background
+- **Support for long running agents**: Infrastructure that can handle long running processes
+- **[Double texting](https://langchain-ai.github.io/langgraph/concepts/double_texting)**: Handle the case where you get two messages from the user before the agent can respond
+- **Handle burstiness**: Task queue for ensuring requests are handled consistently without loss, even under heavy loads
+
+## Installation
+
+```shell
 pip install -U langgraph
 ```
 
-Create a simple workflow:
+## Example
 
-```python
-from langgraph.graph import START, StateGraph
-from typing_extensions import TypedDict
+Let's build a tool-calling [ReAct-style](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/#react-implementation) agent that uses a search tool!
 
-
-class State(TypedDict):
-    text: str
-
-
-def node_a(state: State) -> dict:
-    return {"text": state["text"] + "a"}
-
-
-def node_b(state: State) -> dict:
-    return {"text": state["text"] + "b"}
-
-
-graph = StateGraph(State)
-graph.add_node("node_a", node_a)
-graph.add_node("node_b", node_b)
-graph.add_edge(START, "node_a")
-graph.add_edge("node_a", "node_b")
-
-print(graph.compile().invoke({"text": ""}))
-# {'text': 'ab'}
+```shell
+pip install langchain-anthropic
 ```
 
-Get started with the [LangGraph Quickstart](https://docs.langchain.com/oss/python/langgraph/quickstart).
+```shell
+export ANTHROPIC_API_KEY=sk-...
+```
 
-To quickly build agents with LangChain's `create_agent` (built on LangGraph), see the [LangChain Agents documentation](https://docs.langchain.com/oss/python/langchain/agents).
+Optionally, we can set up [LangSmith](https://docs.smith.langchain.com/) for best-in-class observability.
+
+```shell
+export LANGSMITH_TRACING=true
+export LANGSMITH_API_KEY=lsv2_sk_...
+```
+
+The simplest way to create a tool-calling agent in LangGraph is to use `create_react_agent`:
+
+<details open>
+  <summary>High-level implementation</summary>
+
+```python
+from langgraph.prebuilt import create_react_agent
+from langgraph.checkpoint.memory import MemorySaver
+from langchain_anthropic import ChatAnthropic
+from langchain_core.tools import tool
+
+# Define the tools for the agent to use
+@tool
+def search(query: str):
+    """Call to surf the web."""
+    # This is a placeholder, but don't tell the LLM that...
+    if "sf" in query.lower() or "san francisco" in query.lower():
+        return "It's 60 degrees and foggy."
+    return "It's 90 degrees and sunny."
+
+
+tools = [search]
+model = ChatAnthropic(model="claude-3-5-sonnet-latest", temperature=0)
+
+# Initialize memory to persist state between graph runs
+checkpointer = MemorySaver()
+
+app = create_react_agent(model, tools, checkpointer=checkpointer)
+
+# Use the agent
+final_state = app.invoke(
+    {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
+    config={"configurable": {"thread_id": 42}}
+)
+final_state["messages"][-1].content
+```
+```
+"Based on the search results, I can tell you that the current weather in San Francisco is:\n\nTemperature: 60 degrees Fahrenheit\nConditions: Foggy\n\nSan Francisco is known for its microclimates and frequent fog, especially during the summer months. The temperature of 60°F (about 15.5°C) is quite typical for the city, which tends to have mild temperatures year-round. The fog, often referred to as "Karl the Fog" by locals, is a characteristic feature of San Francisco\'s weather, particularly in the mornings and evenings.\n\nIs there anything else you\'d like to know about the weather in San Francisco or any other location?"
+```
+
+Now when we pass the same <code>"thread_id"</code>, the conversation context is retained via the saved state (i.e. stored list of messages)
+
+```python
+final_state = app.invoke(
+    {"messages": [{"role": "user", "content": "what about ny"}]},
+    config={"configurable": {"thread_id": 42}}
+)
+final_state["messages"][-1].content
+```
+
+```
+"Based on the search results, I can tell you that the current weather in New York City is:\n\nTemperature: 90 degrees Fahrenheit (approximately 32.2 degrees Celsius)\nConditions: Sunny\n\nThis weather is quite different from what we just saw in San Francisco. New York is experiencing much warmer temperatures right now. Here are a few points to note:\n\n1. The temperature of 90°F is quite hot, typical of summer weather in New York City.\n2. The sunny conditions suggest clear skies, which is great for outdoor activities but also means it might feel even hotter due to direct sunlight.\n3. This kind of weather in New York often comes with high humidity, which can make it feel even warmer than the actual temperature suggests.\n\nIt's interesting to see the stark contrast between San Francisco's mild, foggy weather and New York's hot, sunny conditions. This difference illustrates how varied weather can be across different parts of the United States, even on the same day.\n\nIs there anything else you'd like to know about the weather in New York or any other location?"
+```
+</details>
 
 > [!TIP]
-> For developing, debugging, and deploying AI agents and LLM applications, see [LangSmith](https://docs.langchain.com/langsmith/home).
+> LangGraph is a **low-level** framework that allows you to implement any custom agent
+architectures. Click on the low-level implementation below to see how to implement a
+tool-calling agent from scratch.
 
-## Core benefits
+<details>
+<summary>Low-level implementation</summary>
 
-LangGraph provides low-level supporting infrastructure for *any* long-running, stateful workflow or agent. LangGraph does not abstract prompts or architecture, and provides the following central benefits:
+```python
+from typing import Literal
 
-- [Durable execution](https://docs.langchain.com/oss/python/langgraph/durable-execution): Build agents that persist through failures and can run for extended periods, automatically resuming from exactly where they left off.
-- [Human-in-the-loop](https://docs.langchain.com/oss/python/langgraph/interrupts): Seamlessly incorporate human oversight by inspecting and modifying agent state at any point during execution.
-- [Comprehensive memory](https://docs.langchain.com/oss/python/langgraph/memory): Create truly stateful agents with both short-term working memory for ongoing reasoning and long-term persistent memory across sessions.
-- [Debugging with LangSmith](http://www.langchain.com/langsmith): Gain deep visibility into complex agent behavior with visualization tools that trace execution paths, capture state transitions, and provide detailed runtime metrics.
-- [Production-ready deployment](https://docs.langchain.com/langsmith/app-development): Deploy sophisticated agent systems confidently with scalable infrastructure designed to handle the unique challenges of stateful, long-running workflows.
+from langchain_anthropic import ChatAnthropic
+from langchain_core.tools import tool
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.graph import END, START, StateGraph, MessagesState
+from langgraph.prebuilt import ToolNode
 
-## LangGraph’s ecosystem
 
-While LangGraph can be used standalone, it also integrates seamlessly with any LangChain product, giving developers a full suite of tools for building agents. To improve your LLM application development, pair LangGraph with:
+# Define the tools for the agent to use
+@tool
+def search(query: str):
+    """Call to surf the web."""
+    # This is a placeholder, but don't tell the LLM that...
+    if "sf" in query.lower() or "san francisco" in query.lower():
+        return "It's 60 degrees and foggy."
+    return "It's 90 degrees and sunny."
 
-- [LangSmith](http://www.langchain.com/langsmith) — Helpful for agent evals and observability. Debug poor-performing LLM app runs, evaluate agent trajectories, gain visibility in production, and improve performance over time.
-- [LangSmith Deployment](https://docs.langchain.com/langsmith/deployments) — Deploy and scale agents effortlessly with a purpose-built deployment platform for long running, stateful workflows. Discover, reuse, configure, and share agents across teams — and iterate quickly with visual prototyping in [LangGraph Studio](https://docs.langchain.com/oss/python/langgraph/studio).
-- [LangChain](https://docs.langchain.com/oss/python/langchain/overview) – Provides integrations and composable components to streamline LLM application development.
 
-> [!NOTE]
-> Looking for the JS version of LangGraph? See the [JS repo](https://github.com/langchain-ai/langgraphjs) and the [JS docs](https://docs.langchain.com/oss/javascript/langgraph/overview).
+tools = [search]
 
-## Additional resources
+tool_node = ToolNode(tools)
 
-- [Guides](https://docs.langchain.com/oss/python/langgraph/overview): Quick, actionable code snippets for topics such as streaming, adding memory & persistence, and design patterns (e.g. branching, subgraphs, etc.).
-- [Reference](https://reference.langchain.com/python/langgraph/): Detailed reference on core classes, methods, how to use the graph and checkpointing APIs, and higher-level prebuilt components.
-- [Examples](https://docs.langchain.com/oss/python/langgraph/agentic-rag): Guided examples on getting started with LangGraph.
-- [LangChain Forum](https://forum.langchain.com/): Connect with the community and share all of your technical questions, ideas, and feedback.
-- [LangChain Academy](https://academy.langchain.com/courses/intro-to-langgraph): Learn the basics of LangGraph in our free, structured course.
-- [Case studies](https://www.langchain.com/built-with-langgraph): Hear how industry leaders use LangGraph to ship AI applications at scale.
+model = ChatAnthropic(model="claude-3-5-sonnet-latest", temperature=0).bind_tools(tools)
 
-## Acknowledgements
+# Define the function that determines whether to continue or not
+def should_continue(state: MessagesState) -> Literal["tools", END]:
+    messages = state['messages']
+    last_message = messages[-1]
+    # If the LLM makes a tool call, then we route to the "tools" node
+    if last_message.tool_calls:
+        return "tools"
+    # Otherwise, we stop (reply to the user)
+    return END
 
-LangGraph is inspired by [Pregel](https://research.google/pubs/pub37252/) and [Apache Beam](https://beam.apache.org/). The public interface draws inspiration from [NetworkX](https://networkx.org/documentation/latest/). LangGraph is built by LangChain Inc, the creators of LangChain, but can be used without LangChain.
+
+# Define the function that calls the model
+def call_model(state: MessagesState):
+    messages = state['messages']
+    response = model.invoke(messages)
+    # We return a list, because this will get added to the existing list
+    return {"messages": [response]}
+
+
+# Define a new graph
+workflow = StateGraph(MessagesState)
+
+# Define the two nodes we will cycle between
+workflow.add_node("agent", call_model)
+workflow.add_node("tools", tool_node)
+
+# Set the entrypoint as `agent`
+# This means that this node is the first one called
+workflow.add_edge(START, "agent")
+
+# We now add a conditional edge
+workflow.add_conditional_edges(
+    # First, we define the start node. We use `agent`.
+    # This means these are the edges taken after the `agent` node is called.
+    "agent",
+    # Next, we pass in the function that will determine which node is called next.
+    should_continue,
+)
+
+# We now add a normal edge from `tools` to `agent`.
+# This means that after `tools` is called, `agent` node is called next.
+workflow.add_edge("tools", 'agent')
+
+# Initialize memory to persist state between graph runs
+checkpointer = MemorySaver()
+
+# Finally, we compile it!
+# This compiles it into a LangChain Runnable,
+# meaning you can use it as you would any other runnable.
+# Note that we're (optionally) passing the memory when compiling the graph
+app = workflow.compile(checkpointer=checkpointer)
+
+# Use the agent
+final_state = app.invoke(
+    {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
+    config={"configurable": {"thread_id": 42}}
+)
+final_state["messages"][-1].content
+```
+
+<b>Step-by-step Breakdown</b>:
+
+<details>
+<summary>Initialize the model and tools.</summary>
+<ul>
+  <li>
+    We use <code>ChatAnthropic</code> as our LLM. <strong>NOTE:</strong> we need to make sure the model knows that it has these tools available to call. We can do this by converting the LangChain tools into the format for OpenAI tool calling using the <code>.bind_tools()</code> method.
+  </li>
+  <li>
+    We define the tools we want to use - a search tool in our case. It is really easy to create your own tools - see documentation here on how to do that <a href="https://python.langchain.com/docs/how_to/custom_tools/">here</a>.
+  </li>
+</ul>
+</details>
+
+<details>
+<summary>Initialize graph with state.</summary>
+
+<ul>
+    <li>We initialize graph (<code>StateGraph</code>) by passing state schema (in our case <code>MessagesState</code>)</li>
+    <li><code>MessagesState</code> is a prebuilt state schema that has one attribute -- a list of LangChain <code>Message</code> objects, as well as logic for merging the updates from each node into the state.</li>
+</ul>
+</details>
+
+<details>
+<summary>Define graph nodes.</summary>
+
+There are two main nodes we need:
+
+<ul>
+    <li>The <code>agent</code> node: responsible for deciding what (if any) actions to take.</li>
+    <li>The <code>tools</code> node that invokes tools: if the agent decides to take an action, this node will then execute that action.</li>
+</ul>
+</details>
+
+<details>
+<summary>Define entry point and graph edges.</summary>
+
+First, we need to set the entry point for graph execution - <code>agent</code> node.
+
+Then we define one normal and one conditional edge. Conditional edge means that the destination depends on the contents of the graph's state (<code>MessagesState</code>). In our case, the destination is not known until the agent (LLM) decides.
+
+<ul>
+  <li>Conditional edge: after the agent is called, we should either:
+    <ul>
+      <li>a. Run tools if the agent said to take an action, OR</li>
+      <li>b. Finish (respond to the user) if the agent did not ask to run tools</li>
+    </ul>
+  </li>
+  <li>Normal edge: after the tools are invoked, the graph should always return to the agent to decide what to do next</li>
+</ul>
+</details>
+
+<details>
+<summary>Compile the graph.</summary>
+
+<ul>
+  <li>
+    When we compile the graph, we turn it into a LangChain 
+    <a href="https://python.langchain.com/docs/concepts/runnables/">Runnable</a>, 
+    which automatically enables calling <code>.invoke()</code>, <code>.stream()</code> and <code>.batch()</code> 
+    with your inputs
+  </li>
+  <li>
+    We can also optionally pass checkpointer object for persisting state between graph runs, and enabling memory, 
+    human-in-the-loop workflows, time travel and more. In our case we use <code>MemorySaver</code> - 
+    a simple in-memory checkpointer
+  </li>
+</ul>
+</details>
+
+<details>
+<summary>Execute the graph.</summary>
+
+<ol>
+  <li>LangGraph adds the input message to the internal state, then passes the state to the entrypoint node, <code>"agent"</code>.</li>
+  <li>The <code>"agent"</code> node executes, invoking the chat model.</li>
+  <li>The chat model returns an <code>AIMessage</code>. LangGraph adds this to the state.</li>
+  <li>Graph cycles the following steps until there are no more <code>tool_calls</code> on <code>AIMessage</code>:
+    <ul>
+      <li>If <code>AIMessage</code> has <code>tool_calls</code>, <code>"tools"</code> node executes</li>
+      <li>The <code>"agent"</code> node executes again and returns <code>AIMessage</code></li>
+    </ul>
+  </li>
+  <li>Execution progresses to the special <code>END</code> value and outputs the final state. And as a result, we get a list of all our chat messages as output.</li>
+</ol>
+</details>
+
+</details>
+
+## Documentation
+
+* [Tutorials](https://langchain-ai.github.io/langgraph/tutorials/): Learn to build with LangGraph through guided examples.
+* [How-to Guides](https://langchain-ai.github.io/langgraph/how-tos/): Accomplish specific things within LangGraph, from streaming, to adding memory & persistence, to common design patterns (branching, subgraphs, etc.), these are the place to go if you want to copy and run a specific code snippet.
+* [Conceptual Guides](https://langchain-ai.github.io/langgraph/concepts/high_level/): In-depth explanations of the key concepts and principles behind LangGraph, such as nodes, edges, state and more.
+* [API Reference](https://langchain-ai.github.io/langgraph/reference/graphs/): Review important classes and methods, simple examples of how to use the graph and checkpointing APIs, higher-level prebuilt components and more.
+* [LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/#langgraph-platform): LangGraph Platform is a commercial solution for deploying agentic applications in production, built on the open-source LangGraph framework.
+
+## Resources
+
+* [Built with LangGraph](https://www.langchain.com/built-with-langgraph): Hear how industry leaders use LangGraph to ship powerful, production-ready AI applications.
+
+## Contributing
+
+For more information on how to contribute, see [here](https://github.com/langchain-ai/langgraph/blob/main/CONTRIBUTING.md).

advanced-graph-examples/Makefile

@@ -1,6 +0,0 @@
-PYTHON_VERSION ?= 3.13
-
-.PHONY: run-basic
-run-basic:
-	uv run --python $(PYTHON_VERSION) python examples/basic_run.py
-

advanced-graph-examples/README.md

@@ -1,14 +0,0 @@
-# advanced-graph-examples
-
-Examples for the published `saf-python-sdk` package.
-
-## Quick start
-
-```bash
-cd advanced-graph-examples
-uv sync
-uv run python examples/basic_run.py
-```
-
-> Note: current published wheel is for Python 3.13 on macOS arm64.
-

advanced-graph-examples/examples/basic_run.py

@@ -1,36 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from typing import TypedDict
-
-from saf_python_sdk import Command, Send
-from saf_python_sdk.advanced_graph import AdvancedStateGraph
-
-
-class MyState(TypedDict):
-    count: int
-    logs: list[str]
-
-
-async def start_node(state: MyState) -> Command:
-    state["logs"].append("start")
-    return Command(update=state, goto=Send("finish_node", "hello"))
-
-
-async def finish_node(input: str, state: MyState) -> Command:
-    state["logs"].append(f"finish:{input}")
-    state["count"] += 1
-    return Command(update=state)
-
-
-async def main() -> None:
-    graph = AdvancedStateGraph(MyState)
-    graph.add_entry_node(start_node)
-    graph.add_finish_node(finish_node)
-    result = await graph.compile().ainvoke({"count": 0, "logs": []})
-    print(result)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
-

advanced-graph-examples/pyproject.toml

@@ -1,12 +0,0 @@
-[project]
-name = "advanced-graph-examples"
-version = "0.1.0"
-requires-python = ">=3.13,<3.14"
-dependencies = [
-    "saf-python-sdk>=0.1.1",
-]
-
-[tool.uv]
-dev-dependencies = []
-
-

advanced-graph-examples/uv.lock

@@ -1,25 +0,0 @@
-version = 1
-revision = 3
-requires-python = "==3.13.*"
-
-[[package]]
-name = "advanced-graph-examples"
-version = "0.1.0"
-source = { virtual = "." }
-dependencies = [
-    { name = "saf-python-sdk" },
-]
-
-[package.metadata]
-requires-dist = [{ name = "saf-python-sdk", specifier = ">=0.1.1" }]
-
-[package.metadata.requires-dev]
-dev = []
-
-[[package]]
-name = "saf-python-sdk"
-version = "0.1.2"
-source = { registry = "https://pypi.org/simple" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c5/43/2a86cdc8a1fbb185b9ce4642f0e3676acc168d48ed2e68d4ead6ad57e95e/saf_python_sdk-0.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9035ab6ede9884b5588925c47d5b8be2c1c107becf5d6f88e0ebb39f4e8fac3b", size = 517053, upload-time = "2026-03-16T23:49:25.661Z" },
-]

docs/.gitignore

@@ -1 +0,0 @@
-_site/

docs/generate_redirects.py

@@ -1,142 +0,0 @@
-#!/usr/bin/env python3
-"""
-Generate HTML redirect files from redirects.json.
-
-Usage:
-    python generate_redirects.py
-
-This script reads redirects.json and generates individual HTML files
-for each redirect path. Each HTML file uses meta refresh (0 delay)
-which is SEO-friendly and treated similarly to 301 redirects by Google.
-
-To add new redirects, simply edit redirects.json and re-run this script.
-"""
-
-import json
-import os
-from pathlib import Path
-
-# Default fallback URL for any path not in the redirect map
-DEFAULT_REDIRECT = "https://docs.langchain.com/oss/python/langgraph/overview"
-
-HTML_TEMPLATE = """<!doctype html>
-<html lang="en">
-<head>
-    <meta charset="utf-8">
-    <title>Redirecting...</title>
-    <link rel="canonical" href="{url}">
-    <meta name="robots" content="noindex">
-    <script>var anchor=window.location.hash.substr(1);location.href="{url}"+(anchor?"#"+anchor:"")</script>
-    <meta http-equiv="refresh" content="0; url={url}">
-</head>
-<body>
-Redirecting...
-</body>
-</html>
-"""
-
-ROOT_HTML_TEMPLATE = """<!doctype html>
-<html lang="en">
-<head>
-    <meta charset="utf-8">
-    <title>Redirecting to LangGraph Documentation</title>
-    <link rel="canonical" href="{url}">
-    <meta name="robots" content="noindex">
-    <script>var anchor=window.location.hash.substr(1);location.href="{url}"+(anchor?"#"+anchor:"")</script>
-    <meta http-equiv="refresh" content="0; url={url}">
-</head>
-<body>
-<h1>Documentation has moved</h1>
-<p>The LangGraph documentation has moved to <a href="{url}">docs.langchain.com</a>.</p>
-<p>Redirecting you now...</p>
-</body>
-</html>
-"""
-
-CATCHALL_404_TEMPLATE = """<!doctype html>
-<html lang="en">
-<head>
-    <meta charset="utf-8">
-    <title>Redirecting to LangGraph Documentation</title>
-    <link rel="canonical" href="{default_url}">
-    <meta name="robots" content="noindex">
-    <script>
-        // Catchall redirect for any unmapped paths
-        window.location.replace("{default_url}");
-    </script>
-    <meta http-equiv="refresh" content="0; url={default_url}">
-</head>
-<body>
-<h1>Documentation has moved</h1>
-<p>The LangGraph documentation has moved to <a href="{default_url}">docs.langchain.com</a>.</p>
-<p>Redirecting you now...</p>
-</body>
-</html>
-"""
-
-
-def generate_redirects():
-    script_dir = Path(__file__).parent
-    output_dir = script_dir / "_site"
-
-    # Load redirects
-    with open(script_dir / "redirects.json") as f:
-        redirects = json.load(f)
-
-    # Clean output directory
-    if output_dir.exists():
-        import shutil
-        shutil.rmtree(output_dir)
-    output_dir.mkdir(parents=True)
-
-    # Generate individual HTML files for each redirect
-    for old_path, new_url in redirects.items():
-        # Remove leading slash and create directory structure
-        path = old_path.lstrip("/")
-
-        # Check if path has a file extension (e.g., .txt, .xml)
-        # If so, create the file directly instead of a directory with index.html
-        path_obj = Path(path)
-        has_extension = path_obj.suffix and len(path_obj.suffix) <= 5
-
-        if not path:
-            html_path = output_dir / "index.html"
-        elif has_extension:
-            # For files with extensions, create the file directly
-            html_path = output_dir / path
-        else:
-            # For directory-style URLs, create index.html inside
-            html_path = output_dir / path / "index.html"
-
-        # Create parent directories
-        html_path.parent.mkdir(parents=True, exist_ok=True)
-
-        # Write the redirect HTML
-        html_path.write_text(HTML_TEMPLATE.format(url=new_url))
-        print(f"Created: {html_path}")
-
-    # Create root index.html
-    root_index = output_dir / "index.html"
-    if not root_index.exists():
-        root_index.write_text(ROOT_HTML_TEMPLATE.format(url=DEFAULT_REDIRECT))
-        print(f"Created: {root_index}")
-
-    # Create 404.html for catchall
-    catchall_404 = output_dir / "404.html"
-    catchall_404.write_text(CATCHALL_404_TEMPLATE.format(default_url=DEFAULT_REDIRECT))
-    print(f"Created: {catchall_404}")
-
-    # Copy static files (like llms.txt) that can't be redirected via HTML
-    static_files = ["llms.txt"]
-    for static_file in static_files:
-        src = script_dir / static_file
-        if src.exists():
-            dst = output_dir / static_file
-            dst.write_text(src.read_text())
-            print(f"Copied: {dst}")
-
-    print(f"\nGenerated {len(redirects)} redirect files in {output_dir}")
-
-
-if __name__ == "__main__":
-    generate_redirects()

docs/llms.txt

@@ -1,35 +0,0 @@
-# LangGraph
-
-LangGraph documentation has moved to docs.langchain.com.
-
-## Overview
-
-- [LangGraph Overview](https://docs.langchain.com/oss/python/langgraph/overview): Introduction to LangGraph, a library for building stateful, multi-actor applications with LLMs.
-- [Why LangGraph?](https://docs.langchain.com/oss/python/langgraph/why-langgraph): Motivation for LangGraph and its key features.
-
-## Core Concepts
-
-- [Graph API](https://docs.langchain.com/oss/python/langgraph/graph-api): Learn how to define state, create nodes, and connect them with edges.
-- [Streaming](https://docs.langchain.com/oss/python/langgraph/streaming): Stream outputs from your graph for better UX.
-- [Persistence](https://docs.langchain.com/oss/python/langgraph/persistence): Add memory and checkpointing to your graphs.
-- [Add Memory](https://docs.langchain.com/oss/python/langgraph/add-memory): Implement short-term and long-term memory.
-- [Workflows & Agents](https://docs.langchain.com/oss/python/langgraph/workflows-agents): Build agents and workflows with LangGraph.
-
-## How-To Guides
-
-- [Use Subgraphs](https://docs.langchain.com/oss/python/langgraph/use-subgraphs): Compose graphs using subgraphs.
-- [Observability](https://docs.langchain.com/oss/python/langgraph/observability): Add tracing and debugging to your graphs.
-- [Common Errors](https://docs.langchain.com/oss/python/langgraph/common-errors): Troubleshoot common LangGraph errors.
-
-## Tutorials
-
-- [Agentic RAG](https://docs.langchain.com/oss/python/langgraph/agentic-rag): Build an agentic RAG system with LangGraph.
-- [SQL Agent](https://docs.langchain.com/oss/python/langgraph/sql-agent): Create a SQL agent with LangGraph.
-
-## Reference
-
-- [API Reference](https://reference.langchain.com/python/langgraph/): Complete API documentation for LangGraph.
-
-## LangGraph Platform
-
-For deploying LangGraph applications in production, see the [LangSmith documentation](https://docs.langchain.com/langsmith/agent-server).

docs/redirects.json

@@ -1,296 +0,0 @@
-{
-  "/how-tos/stream-values": "https://docs.langchain.com/oss/python/langgraph/streaming",
-  "/how-tos/stream-updates": "https://docs.langchain.com/oss/python/langgraph/streaming",
-  "/how-tos/streaming-content": "https://docs.langchain.com/oss/python/langgraph/streaming",
-  "/how-tos/stream-multiple": "https://docs.langchain.com/oss/python/langgraph/streaming",
-  "/how-tos/streaming-tokens-without-langchain": "https://docs.langchain.com/oss/python/langgraph/streaming",
-  "/how-tos/streaming-from-final-node": "https://docs.langchain.com/oss/python/langgraph/streaming",
-  "/how-tos/streaming-events-from-within-tools-without-langchain": "https://docs.langchain.com/oss/python/langgraph/streaming",
-  "/how-tos/state-reducers": "https://docs.langchain.com/oss/python/langgraph/graph-api#define-and-update-state",
-  "/how-tos/sequence": "https://docs.langchain.com/oss/python/langgraph/graph-api#create-a-sequence-of-steps",
-  "/how-tos/branching": "https://docs.langchain.com/oss/python/langgraph/graph-api#create-branches",
-  "/how-tos/recursion-limit": "https://docs.langchain.com/oss/python/langgraph/graph-api#create-and-control-loops",
-  "/how-tos/visualization": "https://docs.langchain.com/oss/python/langgraph/graph-api#visualize-your-graph",
-  "/how-tos/input_output_schema": "https://docs.langchain.com/oss/python/langgraph/graph-api#define-input-and-output-schemas",
-  "/how-tos/pass_private_state": "https://docs.langchain.com/oss/python/langgraph/graph-api#pass-private-state-between-nodes",
-  "/how-tos/state-model": "https://docs.langchain.com/oss/python/langgraph/graph-api#use-pydantic-models-for-graph-state",
-  "/how-tos/map-reduce": "https://docs.langchain.com/oss/python/langgraph/graph-api#map-reduce-and-the-send-api",
-  "/how-tos/command": "https://docs.langchain.com/oss/python/langgraph/graph-api#combine-control-flow-and-state-updates-with-command",
-  "/how-tos/configuration": "https://docs.langchain.com/oss/python/langgraph/graph-api#add-runtime-configuration",
-  "/how-tos/node-retries": "https://docs.langchain.com/oss/python/langgraph/graph-api#add-retry-policies",
-  "/how-tos/return-when-recursion-limit-hits": "https://docs.langchain.com/oss/python/langgraph/graph-api#impose-a-recursion-limit",
-  "/how-tos/async": "https://docs.langchain.com/oss/python/langgraph/graph-api#async",
-  "/how-tos/memory/manage-conversation-history": "https://docs.langchain.com/oss/python/langgraph/add-memory",
-  "/how-tos/memory/delete-messages": "https://docs.langchain.com/oss/python/langgraph/add-memory#delete-messages",
-  "/how-tos/memory/add-summary-conversation-history": "https://docs.langchain.com/oss/python/langgraph/add-memory#summarize-messages",
-  "/how-tos/memory": "https://docs.langchain.com/oss/python/langgraph/add-memory",
-  "/agents/memory": "https://docs.langchain.com/oss/python/langgraph/add-memory",
-  "/how-tos/subgraph-transform-state": "https://docs.langchain.com/oss/python/langgraph/use-subgraphs#different-state-schemas",
-  "/how-tos/subgraphs-manage-state": "https://docs.langchain.com/oss/python/langgraph/use-subgraphs#add-persistence",
-  "/how-tos/persistence_postgres": "https://docs.langchain.com/oss/python/langgraph/add-memory#use-in-production",
-  "/how-tos/persistence_mongodb": "https://docs.langchain.com/oss/python/langgraph/add-memory#use-in-production",
-  "/how-tos/persistence_redis": "https://docs.langchain.com/oss/python/langgraph/add-memory#use-in-production",
-  "/how-tos/subgraph-persistence": "https://docs.langchain.com/oss/python/langgraph/add-memory#use-with-subgraphs",
-  "/how-tos/cross-thread-persistence": "https://docs.langchain.com/oss/python/langgraph/add-memory#add-long-term-memory",
-  "/cloud/how-tos/copy_threads": "https://docs.langchain.com/langsmith/use-threads",
-  "/cloud/how-tos/check-thread-status": "https://docs.langchain.com/langsmith/use-threads",
-  "/cloud/concepts/threads": "https://docs.langchain.com/oss/python/langgraph/persistence#threads",
-  "/how-tos/persistence": "https://docs.langchain.com/oss/python/langgraph/add-memory",
-  "/how-tos/tool-calling-errors": "https://docs.langchain.com/oss/python/langgraph/workflows-agents",
-  "/how-tos/pass-config-to-tools": "https://docs.langchain.com/oss/python/langgraph/workflows-agents",
-  "/how-tos/pass-run-time-values-to-tools": "https://docs.langchain.com/oss/python/langgraph/workflows-agents",
-  "/how-tos/update-state-from-tools": "https://docs.langchain.com/oss/python/langgraph/workflows-agents",
-  "/agents/tools": "https://docs.langchain.com/oss/python/langgraph/workflows-agents",
-  "/how-tos/agent-handoffs": "https://docs.langchain.com/oss/python/langgraph/graph-api",
-  "/how-tos/multi-agent-network": "https://docs.langchain.com/oss/python/langgraph/graph-api",
-  "/how-tos/multi-agent-multi-turn-convo": "https://docs.langchain.com/oss/python/langgraph/graph-api",
-  "/cloud/index": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/cloud/how-tos/index": "https://docs.langchain.com/langsmith/home",
-  "/cloud/concepts/api": "https://docs.langchain.com/langsmith/agent-server",
-  "/cloud/concepts/cloud": "https://docs.langchain.com/langsmith/cloud",
-  "/cloud/faq/studio": "https://docs.langchain.com/langsmith/studio",
-  "/cloud/how-tos/human_in_the_loop_edit_state": "https://docs.langchain.com/langsmith/add-human-in-the-loop",
-  "/cloud/how-tos/human_in_the_loop_user_input": "https://docs.langchain.com/langsmith/add-human-in-the-loop",
-  "/concepts/platform_architecture": "https://docs.langchain.com/langsmith/cloud#architecture",
-  "/cloud/how-tos/stream_values": "https://docs.langchain.com/langsmith/streaming",
-  "/cloud/how-tos/stream_updates": "https://docs.langchain.com/langsmith/streaming",
-  "/cloud/how-tos/stream_messages": "https://docs.langchain.com/langsmith/streaming",
-  "/cloud/how-tos/stream_events": "https://docs.langchain.com/langsmith/streaming",
-  "/cloud/how-tos/stream_debug": "https://docs.langchain.com/langsmith/streaming",
-  "/cloud/how-tos/stream_multiple": "https://docs.langchain.com/langsmith/streaming",
-  "/cloud/concepts/streaming": "https://docs.langchain.com/oss/python/langgraph/streaming",
-  "/agents/streaming": "https://docs.langchain.com/oss/python/langgraph/streaming",
-  "/how-tos/create-react-agent": "https://docs.langchain.com/oss/python/langchain/agents#basic-configuration",
-  "/how-tos/create-react-agent-memory": "https://docs.langchain.com/oss/python/langgraph/add-memory",
-  "/how-tos/create-react-agent-system-prompt": "https://docs.langchain.com/oss/python/langgraph/add-memory",
-  "/how-tos/create-react-agent-structured-output": "https://docs.langchain.com/oss/python/langchain/agents#structured-output",
-  "/prebuilt": "https://docs.langchain.com/oss/python/langchain/agents",
-  "/reference/prebuilt": "https://reference.langchain.com/python/langgraph/agents/",
-  "/concepts/high_level": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/concepts/index": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/concepts/v0-human-in-the-loop": "https://docs.langchain.com/oss/python/langgraph/interrupts",
-  "/how-tos/index": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/tutorials/introduction": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/agents/deployment": "https://docs.langchain.com/oss/python/langgraph/local-server",
-  "/how-tos/deploy-self-hosted": "https://docs.langchain.com/langsmith/platform-setup",
-  "/concepts/self_hosted": "https://docs.langchain.com/langsmith/platform-setup",
-  "/tutorials/deployment": "https://docs.langchain.com/langsmith/deployments",
-  "/cloud/how-tos/assistant_versioning": "https://docs.langchain.com/langsmith/configuration-cloud",
-  "/cloud/concepts/runs": "https://docs.langchain.com/langsmith/assistants#execution",
-  "/how-tos/wait-user-input-functional": "https://docs.langchain.com/oss/python/langgraph/functional-api",
-  "/how-tos/review-tool-calls-functional": "https://docs.langchain.com/oss/python/langgraph/functional-api",
-  "/how-tos/create-react-agent-hitl": "https://docs.langchain.com/oss/python/langgraph/interrupts",
-  "/agents/human-in-the-loop": "https://docs.langchain.com/oss/python/langgraph/interrupts",
-  "/how-tos/human_in_the_loop/dynamic_breakpoints": "https://docs.langchain.com/oss/python/langgraph/interrupts",
-  "/concepts/breakpoints": "https://docs.langchain.com/oss/python/langgraph/interrupts",
-  "/how-tos/human_in_the_loop/breakpoints": "https://docs.langchain.com/oss/python/langgraph/interrupts",
-  "/cloud/how-tos/human_in_the_loop_breakpoint": "https://docs.langchain.com/langsmith/add-human-in-the-loop",
-  "/how-tos/human_in_the_loop/edit-graph-state": "https://docs.langchain.com/oss/python/langgraph/use-time-travel",
-  "/examples/index": "https://docs.langchain.com/oss/python/langgraph/case-studies",
-  "/guides/index": "https://docs.langchain.com/oss/python/langchain/overview",
-  "/tutorials/index": "https://docs.langchain.com/oss/python/learn",
-  "/llms-txt-overview": "https://docs.langchain.com/llms.txt",
-  "/tutorials/rag/langgraph_adaptive_rag": "https://docs.langchain.com/oss/python/langgraph/agentic-rag",
-  "/tutorials/multi_agent/multi-agent-collaboration": "https://docs.langchain.com/oss/python/langchain/multi-agent",
-  "/how-tos/create-react-agent-manage-message-history": "https://docs.langchain.com/oss/python/langgraph/add-memory",
-  "/how-tos/many-tools": "https://docs.langchain.com/oss/python/langchain/tools",
-  "/tutorials/customer-support/customer-support": "https://docs.langchain.com/oss/python/langgraph/agentic-rag",
-  "/how-tos/react-agent-structured-output": "https://docs.langchain.com/oss/python/langchain/agents#structured-output",
-  "/tutorials/code_assistant/langgraph_code_assistant": "https://docs.langchain.com/oss/python/langgraph/agentic-rag",
-  "/tutorials/multi_agent/hierarchical_agent_teams": "https://docs.langchain.com/oss/python/langchain/supervisor",
-  "/tutorials/auth/getting_started": "https://docs.langchain.com/langsmith/auth",
-  "/tutorials/auth/resource_auth": "https://docs.langchain.com/langsmith/resource-auth",
-  "/tutorials/auth/add_auth_server": "https://docs.langchain.com/langsmith/add-auth-server",
-  "/how-tos/use-remote-graph": "https://docs.langchain.com/langsmith/use-remote-graph",
-  "/how-tos/autogen-integration": "https://docs.langchain.com/langsmith/autogen-integration",
-  "/how-tos/human_in_the_loop/wait-user-input": "https://docs.langchain.com/oss/python/langgraph/interrupts",
-  "/cloud/how-tos/use_stream_react": "https://docs.langchain.com/langsmith/use-stream-react",
-  "/cloud/how-tos/generative_ui_react": "https://docs.langchain.com/langsmith/generative-ui-react",
-  "/concepts/langgraph_platform": "https://docs.langchain.com/langsmith/home",
-  "/concepts/langgraph_components": "https://docs.langchain.com/langsmith/components",
-  "/concepts/langgraph_server": "https://docs.langchain.com/langsmith/agent-server",
-  "/concepts/langgraph_data_plane": "https://docs.langchain.com/langsmith/data-plane",
-  "/concepts/langgraph_control_plane": "https://docs.langchain.com/langsmith/control-plane",
-  "/concepts/langgraph_cli": "https://docs.langchain.com/langsmith/cli",
-  "/concepts/langgraph_studio": "https://docs.langchain.com/langsmith/studio",
-  "/cloud/how-tos/studio/quick_start": "https://docs.langchain.com/langsmith/quick-start-studio",
-  "/cloud/how-tos/invoke_studio": "https://docs.langchain.com/langsmith/use-studio",
-  "/cloud/how-tos/studio/manage_assistants": "https://docs.langchain.com/langsmith/use-studio",
-  "/cloud/how-tos/threads_studio": "https://docs.langchain.com/langsmith/use-threads",
-  "/cloud/how-tos/iterate_graph_studio": "https://docs.langchain.com/langsmith/use-studio",
-  "/cloud/how-tos/studio/run_evals": "https://docs.langchain.com/langsmith/observability",
-  "/cloud/how-tos/clone_traces_studio": "https://docs.langchain.com/langsmith/observability",
-  "/cloud/how-tos/datasets_studio": "https://docs.langchain.com/langsmith/use-studio",
-  "/concepts/sdk": "https://docs.langchain.com/langsmith/sdk",
-  "/concepts/plans": "https://docs.langchain.com/langsmith/home",
-  "/concepts/application_structure": "https://docs.langchain.com/langsmith/application-structure",
-  "/concepts/scalability_and_resilience": "https://docs.langchain.com/langsmith/scalability-and-resilience",
-  "/concepts/auth": "https://docs.langchain.com/langsmith/auth",
-  "/how-tos/auth/custom_auth": "https://docs.langchain.com/langsmith/custom-auth",
-  "/how-tos/auth/openapi_security": "https://docs.langchain.com/langsmith/openapi-security",
-  "/concepts/assistants": "https://docs.langchain.com/langsmith/assistants",
-  "/cloud/how-tos/configuration_cloud": "https://docs.langchain.com/langsmith/configuration-cloud",
-  "/cloud/how-tos/use_threads": "https://docs.langchain.com/langsmith/use-threads",
-  "/cloud/how-tos/background_run": "https://docs.langchain.com/langsmith/background-run",
-  "/cloud/how-tos/same-thread": "https://docs.langchain.com/langsmith/same-thread",
-  "/cloud/how-tos/stateless_runs": "https://docs.langchain.com/langsmith/stateless-runs",
-  "/cloud/how-tos/configurable_headers": "https://docs.langchain.com/langsmith/configurable-headers",
-  "/concepts/double_texting": "https://docs.langchain.com/langsmith/double-texting",
-  "/cloud/how-tos/interrupt_concurrent": "https://docs.langchain.com/langsmith/interrupt-concurrent",
-  "/cloud/how-tos/rollback_concurrent": "https://docs.langchain.com/langsmith/rollback-concurrent",
-  "/cloud/how-tos/reject_concurrent": "https://docs.langchain.com/langsmith/reject-concurrent",
-  "/cloud/how-tos/enqueue_concurrent": "https://docs.langchain.com/langsmith/enqueue-concurrent",
-  "/cloud/concepts/webhooks": "https://docs.langchain.com/langsmith/use-webhooks",
-  "/cloud/how-tos/webhooks": "https://docs.langchain.com/langsmith/use-webhooks",
-  "/cloud/concepts/cron_jobs": "https://docs.langchain.com/langsmith/cron-jobs",
-  "/cloud/how-tos/cron_jobs": "https://docs.langchain.com/langsmith/cron-jobs",
-  "/how-tos/http/custom_lifespan": "https://docs.langchain.com/langsmith/custom-lifespan",
-  "/how-tos/http/custom_middleware": "https://docs.langchain.com/langsmith/custom-middleware",
-  "/how-tos/http/custom_routes": "https://docs.langchain.com/langsmith/custom-routes",
-  "/cloud/concepts/data_storage_and_privacy": "https://docs.langchain.com/langsmith/data-storage-and-privacy",
-  "/cloud/deployment/semantic_search": "https://docs.langchain.com/langsmith/semantic-search",
-  "/how-tos/ttl/configure_ttl": "https://docs.langchain.com/langsmith/configure-ttl",
-  "/concepts/deployment_options": "https://docs.langchain.com/langsmith/deployments",
-  "/cloud/quick_start": "https://docs.langchain.com/langsmith/deployment-quickstart",
-  "/cloud/deployment/setup": "https://docs.langchain.com/langsmith/setup-app-requirements-txt",
-  "/cloud/deployment/setup_pyproject": "https://docs.langchain.com/langsmith/setup-pyproject",
-  "/cloud/deployment/setup_javascript": "https://docs.langchain.com/langsmith/setup-javascript",
-  "/cloud/deployment/custom_docker": "https://docs.langchain.com/langsmith/custom-docker",
-  "/cloud/deployment/graph_rebuild": "https://docs.langchain.com/langsmith/graph-rebuild",
-  "/concepts/langgraph_cloud": "https://docs.langchain.com/langsmith/cloud",
-  "/concepts/langgraph_self_hosted_data_plane": "https://docs.langchain.com/langsmith/platform-setup",
-  "/concepts/langgraph_self_hosted_control_plane": "https://docs.langchain.com/langsmith/platform-setup",
-  "/concepts/langgraph_standalone_container": "https://docs.langchain.com/langsmith/docker",
-  "/cloud/deployment/cloud": "https://docs.langchain.com/langsmith/cloud",
-  "/cloud/deployment/self_hosted_data_plane": "https://docs.langchain.com/langsmith/platform-setup",
-  "/cloud/deployment/self_hosted_control_plane": "https://docs.langchain.com/langsmith/platform-setup",
-  "/cloud/deployment/standalone_container": "https://docs.langchain.com/langsmith/docker",
-  "/concepts/server-mcp": "https://docs.langchain.com/langsmith/server-mcp",
-  "/cloud/how-tos/human_in_the_loop_time_travel": "https://docs.langchain.com/langsmith/human-in-the-loop-time-travel",
-  "/cloud/how-tos/add-human-in-the-loop": "https://docs.langchain.com/langsmith/add-human-in-the-loop",
-  "/cloud/deployment/egress": "https://docs.langchain.com/langsmith/env-var",
-  "/cloud/how-tos/streaming": "https://docs.langchain.com/langsmith/streaming",
-  "/cloud/reference/api/api_ref": "https://docs.langchain.com/langsmith/server-api-ref",
-  "/cloud/reference/langgraph_server_changelog": "https://docs.langchain.com/langsmith/agent-server-changelog",
-  "/cloud/reference/api/api_ref_control_plane": "https://docs.langchain.com/langsmith/api-ref-control-plane",
-  "/cloud/reference/cli": "https://docs.langchain.com/langsmith/cli",
-  "/cloud/reference/env_var": "https://docs.langchain.com/langsmith/env-var",
-  "/troubleshooting/studio": "https://docs.langchain.com/langsmith/troubleshooting-studio",
-  "/index": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/agents/agents": "https://docs.langchain.com/oss/python/langchain/agents",
-  "/concepts/why-langgraph": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/tutorials/get-started/1-build-basic-chatbot": "https://docs.langchain.com/oss/python/langgraph/quickstart",
-  "/tutorials/get-started/2-add-tools": "https://docs.langchain.com/oss/python/langgraph/quickstart",
-  "/tutorials/get-started/3-add-memory": "https://docs.langchain.com/oss/python/langgraph/quickstart",
-  "/tutorials/get-started/4-human-in-the-loop": "https://docs.langchain.com/oss/python/langgraph/quickstart",
-  "/tutorials/get-started/5-customize-state": "https://docs.langchain.com/oss/python/langgraph/quickstart",
-  "/tutorials/get-started/6-time-travel": "https://docs.langchain.com/oss/python/langgraph/quickstart",
-  "/tutorials/langsmith/local-server": "https://docs.langchain.com/oss/python/langgraph/local-server",
-  "/tutorials/workflows": "https://docs.langchain.com/oss/python/langgraph/workflows-agents",
-  "/tutorials/plan-and-execute/plan-and-execute": "https://docs.langchain.com/oss/python/langchain/middleware/built-in#to-do-list",
-  "/tutorials/langgraph-platform/local-server/local-server": "https://docs.langchain.com/langsmith/local-server",
-  "/concepts/agentic_concepts": "https://docs.langchain.com/oss/python/langgraph/workflows-agents",
-  "/agents/overview": "https://docs.langchain.com/oss/python/langchain/agents",
-  "/agents/run_agents": "https://docs.langchain.com/oss/python/langgraph/quickstart",
-  "/concepts/low_level": "https://docs.langchain.com/oss/python/langgraph/graph-api",
-  "/how-tos/graph-api": "https://docs.langchain.com/oss/python/langgraph/graph-api",
-  "/how-tos/react-agent-from-scratch": "https://docs.langchain.com/oss/python/langchain/quickstart",
-  "/concepts/functional_api": "https://docs.langchain.com/oss/python/langgraph/functional-api",
-  "/how-tos/use-functional-api": "https://docs.langchain.com/oss/python/langgraph/functional-api",
-  "/concepts/pregel": "https://docs.langchain.com/oss/python/langgraph/pregel",
-  "/concepts/streaming": "https://docs.langchain.com/oss/python/langgraph/streaming",
-  "/how-tos/streaming": "https://docs.langchain.com/oss/python/langgraph/streaming",
-  "/concepts/persistence": "https://docs.langchain.com/oss/python/langgraph/persistence",
-  "/concepts/durable_execution": "https://docs.langchain.com/oss/python/langgraph/durable-execution",
-  "/concepts/memory": "https://docs.langchain.com/oss/python/langgraph/memory",
-  "/how-tos/memory/add-memory": "https://docs.langchain.com/oss/python/langgraph/add-memory",
-  "/agents/context": "https://docs.langchain.com/oss/python/langgraph/add-memory",
-  "/agents/models": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/concepts/tools": "https://docs.langchain.com/oss/python/langgraph/workflows-agents",
-  "/how-tos/tool-calling": "https://docs.langchain.com/oss/python/langgraph/workflows-agents",
-  "/concepts/human_in_the_loop": "https://docs.langchain.com/oss/python/langgraph/interrupts",
-  "/how-tos/human_in_the_loop/add-human-in-the-loop": "https://docs.langchain.com/oss/python/langgraph/interrupts",
-  "/concepts/time-travel": "https://docs.langchain.com/oss/python/langgraph/persistence",
-  "/how-tos/human_in_the_loop/time-travel": "https://docs.langchain.com/oss/python/langgraph/use-time-travel",
-  "/concepts/subgraphs": "https://docs.langchain.com/oss/python/langgraph/use-subgraphs",
-  "/how-tos/subgraph": "https://docs.langchain.com/oss/python/langgraph/use-subgraphs",
-  "/concepts/multi_agent": "https://docs.langchain.com/oss/python/langgraph/graph-api",
-  "/agents/multi-agent": "https://docs.langchain.com/oss/python/langchain/multi-agent",
-  "/how-tos/multi_agent": "https://docs.langchain.com/oss/python/langgraph/graph-api",
-  "/concepts/mcp": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/agents/mcp": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/concepts/tracing": "https://docs.langchain.com/oss/python/langgraph/observability",
-  "/how-tos/enable-tracing": "https://docs.langchain.com/oss/python/langgraph/observability",
-  "/agents/evals": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/concepts/template_applications": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/tutorials/rag/langgraph_agentic_rag": "https://docs.langchain.com/oss/python/langgraph/agentic-rag",
-  "/tutorials/multi_agent/agent_supervisor": "https://docs.langchain.com/oss/python/langgraph/workflows-agents",
-  "/tutorials/sql/sql-agent": "https://docs.langchain.com/oss/python/langgraph/sql-agent",
-  "/agents/ui": "https://docs.langchain.com/oss/python/langgraph/ui",
-  "/how-tos/run-id-langsmith": "https://docs.langchain.com/oss/python/langgraph/observability",
-  "/troubleshooting/errors/index": "https://docs.langchain.com/oss/python/langgraph/common-errors",
-  "/troubleshooting/errors/INVALID_CHAT_HISTORY": "https://docs.langchain.com/oss/python/langgraph/INVALID_CHAT_HISTORY",
-  "/troubleshooting/errors/INVALID_LICENSE": "https://docs.langchain.com/oss/python/langgraph/common-errors",
-  "/adopters": "https://docs.langchain.com/oss/python/langgraph/case-studies",
-  "/concepts/faq": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/agents/prebuilt": "https://docs.langchain.com/oss/python/langchain/agents",
-  "/reference/index": "https://reference.langchain.com/python/langgraph/",
-  "/reference/graphs": "https://reference.langchain.com/python/langgraph/graphs/",
-  "/reference/func": "https://reference.langchain.com/python/langgraph/func/",
-  "/reference/pregel": "https://reference.langchain.com/python/langgraph/pregel/",
-  "/reference/checkpoints": "https://reference.langchain.com/python/langgraph/checkpoints/",
-  "/reference/store": "https://reference.langchain.com/python/langgraph/store/",
-  "/reference/cache": "https://reference.langchain.com/python/langgraph/cache/",
-  "/reference/types": "https://reference.langchain.com/python/langgraph/types/",
-  "/reference/runtime": "https://reference.langchain.com/python/langgraph/runtime/",
-  "/reference/config": "https://reference.langchain.com/python/langgraph/config/",
-  "/reference/errors": "https://reference.langchain.com/python/langgraph/errors/",
-  "/reference/constants": "https://reference.langchain.com/python/langgraph/constants/",
-  "/reference/channels": "https://reference.langchain.com/python/langgraph/channels/",
-  "/reference/agents": "https://reference.langchain.com/python/langgraph/agents/",
-  "/reference/supervisor": "https://reference.langchain.com/python/langgraph/supervisor/",
-  "/reference/swarm": "https://reference.langchain.com/python/langgraph/swarm/",
-  "/reference/mcp": "https://reference.langchain.com/python/langgraph/mcp/",
-  "/cloud/reference/sdk/python_sdk_ref": "https://reference.langchain.com/python/langsmith/deployment/sdk/",
-  "/reference/remote_graph": "https://reference.langchain.com/python/langsmith/deployment/remote_graph/",
-  "/additional-resources/index": "https://docs.langchain.com/oss/python/langchain/overview",
-  "/cloud/reference/sdk/js_ts_sdk_ref": "https://reference.langchain.com/javascript/modules/langsmith.html",
-  "/snippets/chat_model_tabs": "https://docs.langchain.com/oss/python/langchain/overview",
-  "/troubleshooting/errors/GRAPH_RECURSION_LIMIT": "https://docs.langchain.com/oss/python/langgraph/GRAPH_RECURSION_LIMIT",
-  "/troubleshooting/errors/INVALID_CONCURRENT_GRAPH_UPDATE": "https://docs.langchain.com/oss/python/langgraph/INVALID_CONCURRENT_GRAPH_UPDATE",
-  "/troubleshooting/errors/INVALID_GRAPH_NODE_RETURN_VALUE": "https://docs.langchain.com/oss/python/langgraph/INVALID_GRAPH_NODE_RETURN_VALUE",
-  "/troubleshooting/errors/MULTIPLE_SUBGRAPHS": "https://docs.langchain.com/oss/python/langgraph/MULTIPLE_SUBGRAPHS",
-  "/tutorials/rag/langgraph_self_rag": "https://docs.langchain.com/oss/python/langgraph/agentic-rag",
-  "/additional-resources": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/examples": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/guides": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/how-tos/autogen-integration-functional": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/how-tos/cross-thread-persistence-functional": "https://docs.langchain.com/oss/python/langgraph/add-memory#add-long-term-memory",
-  "/how-tos/disable-streaming": "https://docs.langchain.com/oss/python/langgraph/streaming",
-  "/how-tos/memory/semantic-search": "https://docs.langchain.com/oss/python/langgraph/add-memory",
-  "/how-tos/multi-agent-multi-turn-convo-functional": "https://docs.langchain.com/oss/python/langgraph/graph-api",
-  "/how-tos/multi-agent-network-functional": "https://docs.langchain.com/oss/python/langgraph/graph-api",
-  "/how-tos/persistence-functional": "https://docs.langchain.com/oss/python/langgraph/add-memory",
-  "/how-tos/react-agent-from-scratch-functional": "https://docs.langchain.com/oss/python/langgraph/workflows-agents",
-  "/reference": "https://reference.langchain.com/python/langgraph/",
-  "/troubleshooting/errors": "https://docs.langchain.com/oss/python/langgraph/common-errors",
-  "/tutorials/chatbot-simulation-evaluation/agent-simulation-evaluation": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/tutorials/chatbot-simulation-evaluation/langsmith-agent-simulation-evaluation": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/tutorials/chatbots/information-gather-prompting": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/tutorials/extraction/retries": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/tutorials/langgraph-platform/local-server": "https://docs.langchain.com/langsmith/agent-server",
-  "/tutorials/lats/lats": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/tutorials/llm-compiler/LLMCompiler": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/tutorials/rag/langgraph_adaptive_rag_local": "https://docs.langchain.com/oss/python/langgraph/agentic-rag",
-  "/tutorials/rag/langgraph_crag": "https://docs.langchain.com/oss/python/langgraph/agentic-rag",
-  "/tutorials/rag/langgraph_crag_local": "https://docs.langchain.com/oss/python/langgraph/agentic-rag",
-  "/tutorials/rag/langgraph_self_rag_local": "https://docs.langchain.com/oss/python/langgraph/agentic-rag",
-  "/tutorials/reflection/reflection": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/tutorials/reflexion/reflexion": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/tutorials/rewoo/rewoo": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/tutorials/self-discover/self-discover": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/tutorials/tnt-llm/tnt-llm": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/tutorials/tot/tot": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/tutorials/usaco/usaco": "https://docs.langchain.com/oss/python/langgraph/overview",
-  "/tutorials/web-navigation/web_voyager": "https://docs.langchain.com/oss/python/langgraph/overview"
-}

examples/README.md

@@ -1,3 +0,0 @@
-# LangGraph examples
-
-This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview). Please refer to the LangChain docs for the most up-to-date examples and usage guidelines for LangGraph.

examples/chatbot-simulation-evaluation/agent-simulation-evaluation.ipynb

@@ -1,41 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "10251c1c",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/chatbot-simulation-evaluation/agent-simulation-evaluation.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c5fc63df",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.1"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/chatbot-simulation-evaluation/langsmith-agent-simulation-evaluation.ipynb

@@ -1,41 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "a4351a24",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/chatbot-simulation-evaluation/langsmith-agent-simulation-evaluation.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "4cc9af1e",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/chatbot-simulation-evaluation/simulation_utils.py

@@ -1,203 +0,0 @@
-import functools
-from typing import Annotated, Any, Callable, Dict, List, Optional, Union
-
-from langchain_community.adapters.openai import convert_message_to_dict
-from langchain_core.messages import AIMessage, AnyMessage, BaseMessage, HumanMessage
-from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
-from langchain_core.runnables import Runnable, RunnableLambda
-from langchain_core.runnables import chain as as_runnable
-from langchain_openai import ChatOpenAI
-from typing_extensions import TypedDict
-
-from langgraph.graph import END, StateGraph, START
-
-
-def langchain_to_openai_messages(messages: List[BaseMessage]):
-    """
-    Convert a list of langchain base messages to a list of openai messages.
-
-    Parameters:
-        messages (List[BaseMessage]): A list of langchain base messages.
-
-    Returns:
-        List[dict]: A list of openai messages.
-    """
-
-    return [
-        convert_message_to_dict(m) if isinstance(m, BaseMessage) else m
-        for m in messages
-    ]
-
-
-def create_simulated_user(
-    system_prompt: str, llm: Runnable | None = None
-) -> Runnable[Dict, AIMessage]:
-    """
-    Creates a simulated user for chatbot simulation.
-
-    Args:
-        system_prompt (str): The system prompt to be used by the simulated user.
-        llm (Runnable | None, optional): The language model to be used for the simulation.
-            Defaults to gpt-3.5-turbo.
-
-    Returns:
-        Runnable[Dict, AIMessage]: The simulated user for chatbot simulation.
-    """
-    return ChatPromptTemplate.from_messages(
-        [
-            ("system", system_prompt),
-            MessagesPlaceholder(variable_name="messages"),
-        ]
-    ) | (llm or ChatOpenAI(model="gpt-3.5-turbo")).with_config(
-        run_name="simulated_user"
-    )
-
-
-Messages = Union[list[AnyMessage], AnyMessage]
-
-
-def add_messages(left: Messages, right: Messages) -> Messages:
-    if not isinstance(left, list):
-        left = [left]
-    if not isinstance(right, list):
-        right = [right]
-    return left + right
-
-
-class SimulationState(TypedDict):
-    """
-    Represents the state of a simulation.
-
-    Attributes:
-        messages (List[AnyMessage]): A list of messages in the simulation.
-        inputs (Optional[dict[str, Any]]): Optional inputs for the simulation.
-    """
-
-    messages: Annotated[List[AnyMessage], add_messages]
-    inputs: Optional[dict[str, Any]]
-
-
-def create_chat_simulator(
-    assistant: (
-        Callable[[List[AnyMessage]], str | AIMessage]
-        | Runnable[List[AnyMessage], str | AIMessage]
-    ),
-    simulated_user: Runnable[Dict, AIMessage],
-    *,
-    input_key: str,
-    max_turns: int = 6,
-    should_continue: Optional[Callable[[SimulationState], str]] = None,
-):
-    """Creates a chat simulator for evaluating a chatbot.
-
-    Args:
-        assistant: The chatbot assistant function or runnable object.
-        simulated_user: The simulated user object.
-        input_key: The key for the input to the chat simulation.
-        max_turns: The maximum number of turns in the chat simulation. Default is 6.
-        should_continue: Optional function to determine if the simulation should continue.
-            If not provided, a default function will be used.
-
-    Returns:
-        The compiled chat simulation graph.
-
-    """
-    graph_builder = StateGraph(SimulationState)
-    graph_builder.add_node(
-        "user",
-        _create_simulated_user_node(simulated_user),
-    )
-    graph_builder.add_node(
-        "assistant", _fetch_messages | assistant | _coerce_to_message
-    )
-    graph_builder.add_edge("assistant", "user")
-    graph_builder.add_conditional_edges(
-        "user",
-        should_continue or functools.partial(_should_continue, max_turns=max_turns),
-    )
-    # If your dataset has a 'leading question/input', then we route first to the assistant, otherwise, we let the user take the lead.
-    graph_builder.add_edge(START, "assistant" if input_key is not None else "user")
-
-    return (
-        RunnableLambda(_prepare_example).bind(input_key=input_key)
-        | graph_builder.compile()
-    )
-
-
-## Private methods
-
-
-def _prepare_example(inputs: dict[str, Any], input_key: Optional[str] = None):
-    if input_key is not None:
-        if input_key not in inputs:
-            raise ValueError(
-                f"Dataset's example input must contain the provided input key: '{input_key}'.\nFound: {list(inputs.keys())}"
-            )
-        messages = [HumanMessage(content=inputs[input_key])]
-        return {
-            "inputs": {k: v for k, v in inputs.items() if k != input_key},
-            "messages": messages,
-        }
-    return {"inputs": inputs, "messages": []}
-
-
-def _invoke_simulated_user(state: SimulationState, simulated_user: Runnable):
-    """Invoke the simulated user node."""
-    runnable = (
-        simulated_user
-        if isinstance(simulated_user, Runnable)
-        else RunnableLambda(simulated_user)
-    )
-    inputs = state.get("inputs", {})
-    inputs["messages"] = state["messages"]
-    return runnable.invoke(inputs)
-
-
-def _swap_roles(state: SimulationState):
-    new_messages = []
-    for m in state["messages"]:
-        if isinstance(m, AIMessage):
-            new_messages.append(HumanMessage(content=m.content))
-        else:
-            new_messages.append(AIMessage(content=m.content))
-    return {
-        "inputs": state.get("inputs", {}),
-        "messages": new_messages,
-    }
-
-
-@as_runnable
-def _fetch_messages(state: SimulationState):
-    """Invoke the simulated user node."""
-    return state["messages"]
-
-
-def _convert_to_human_message(message: BaseMessage):
-    return {"messages": [HumanMessage(content=message.content)]}
-
-
-def _create_simulated_user_node(simulated_user: Runnable):
-    """Simulated user accepts a {"messages": [...]} argument and returns a single message."""
-    return (
-        _swap_roles
-        | RunnableLambda(_invoke_simulated_user).bind(simulated_user=simulated_user)
-        | _convert_to_human_message
-    )
-
-
-def _coerce_to_message(assistant_output: str | BaseMessage):
-    if isinstance(assistant_output, str):
-        return {"messages": [AIMessage(content=assistant_output)]}
-    else:
-        return {"messages": [assistant_output]}
-
-
-def _should_continue(state: SimulationState, max_turns: int = 6):
-    messages = state["messages"]
-    # TODO support other stop criteria
-    if len(messages) > max_turns:
-        return END
-    elif messages[-1].content.strip() == "FINISHED":
-        return END
-    else:
-        return "assistant"

examples/chatbots/information-gather-prompting.ipynb

@@ -1,41 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "a9014f94",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/chatbots/information-gather-prompting.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f47ce992",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/code_assistant/langgraph_code_assistant.ipynb

@@ -1,41 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "1f2f13ca",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/code_assistant/langgraph_code_assistant.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5e4c9bfe",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/customer-support/customer-support.ipynb

@@ -1,41 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "a8232bc9",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/customer-support/customer-support.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "63da8671",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/extraction/retries.ipynb

@@ -1,41 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "8dbdba5b",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/extraction/retries.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1d444b7f",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/human_in_the_loop/wait-user-input.ipynb

@@ -1,41 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "3ecab357",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/how-tos/human_in_the_loop/wait-user-input.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "3f2866bd",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/lats/lats.ipynb

@@ -1,41 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "09038b53",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/lats/lats.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b1669748",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/llm-compiler/LLMCompiler.ipynb

@@ -1,41 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "85205e97",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/llm-compiler/LLMCompiler.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "2fdab366",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/multi_agent/hierarchical_agent_teams.ipynb

@@ -1,41 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "5cc8a2ad",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/multi_agent/hierarchical_agent_teams.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b9f3508a",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/multi_agent/multi-agent-collaboration.ipynb

@@ -1,41 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "d2b507b9",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/multi_agent/multi-agent-collaboration.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "41a8f10a",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/plan-and-execute/plan-and-execute.ipynb

@@ -1,41 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "9138f92e",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/plan-and-execute/plan-and-execute.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "093678ba",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/react-agent-from-scratch.ipynb

@@ -1,40 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "294995c4",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/how-tos/react-agent-from-scratch.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

examples/react-agent-structured-output.ipynb

@@ -1,40 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "40f0d107",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/how-tos/react-agent-structured-output.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

examples/reflection/reflection.ipynb

@@ -1,41 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "658773a2",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/reflection/reflection.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1cb60657",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/reflexion/reflexion.ipynb

@@ -1,41 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "caf07859",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/reflexion/reflexion.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cd1df0e0",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/rewoo/rewoo.ipynb

@@ -1,41 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "961f43ec",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/rewoo/rewoo.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7f00c427",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/run-id-langsmith.ipynb

@@ -1,40 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "bbd6e9b8",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/how-tos/run-id-langsmith.md)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

examples/self-discover/self-discover.ipynb

@@ -1,41 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "f6db1873",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/self-discover/self-discover.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "219a78f9",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/subgraph.ipynb

@@ -1,40 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "f49876e1",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/how-tos/subgraph.md)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

examples/tool-calling.ipynb

@@ -1,40 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "7fd8bd65",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/how-tos/tool-calling.md)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

examples/tutorials/sql-agent.ipynb

@@ -1,41 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "83c2223f",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/sql/sql-agent.md)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "57f924b1",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/tutorials/tnt-llm/tnt-llm.ipynb

@@ -1,41 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "11140167",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/tnt-llm/tnt-llm.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1a2ba3e6",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/usaco/usaco.ipynb

@@ -1,41 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "9dffdb54",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/usaco/usaco.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "579c9959",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/web-navigation/web_voyager.ipynb

@@ -1,41 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "007ea2e9",
-   "metadata": {},
-   "source": [
-    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/web-navigation/web_voyager.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f0d7b895",
-   "metadata": {},
-   "source": [
-    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

langgraph-go/advancedgraph/graph.go

@@ -1,581 +0,0 @@
-package advancedgraph
-
-import (
-	"encoding/json"
-	"fmt"
-	"reflect"
-	"runtime"
-	"strings"
-)
-
-type nodeExecutor func(ctx *Context, input any, state map[string]any) (Command, error)
-
-type nodeConfig struct {
-	lockedFields []string
-}
-
-type NodeOption interface {
-	applyToNodeConfig(*nodeConfig)
-}
-
-type NodeStateOption struct {
-	LockedFields []string
-}
-
-func (o NodeStateOption) applyToNodeConfig(cfg *nodeConfig) {
-	if cfg == nil {
-		return
-	}
-	cfg.lockedFields = append(cfg.lockedFields[:0], o.LockedFields...)
-}
-
-type AdvancedStateGraph[StateT any] struct {
-	nodes         map[string]nodeExecutor
-	nodeOptions   map[string]nodeConfig
-	asyncChannels []string
-	customStreams []string
-	entryPoint    string
-	finishPoint   string
-	stateType     reflect.Type
-}
-
-func NewAdvancedStateGraph[StateT any]() *AdvancedStateGraph[StateT] {
-	stateType := mustTypeOf[StateT]()
-	if stateType.Kind() != reflect.Struct {
-		panic(fmt.Sprintf("StateT must be a struct, got %s", stateType.String()))
-	}
-	return &AdvancedStateGraph[StateT]{
-		nodes:       make(map[string]nodeExecutor),
-		nodeOptions: make(map[string]nodeConfig),
-		stateType:   stateType,
-	}
-}
-
-// AddNode keeps `fn` as `any` because advanced graph nodes can have different
-// input argument types per node, while only `StateT` is globally constrained.
-// We validate and adapt node signatures at runtime in compileNodeExecutor.
-func (g *AdvancedStateGraph[StateT]) AddNode(fn any, nodeOption ...NodeOption) string {
-	name := NodeName(fn)
-	return g.AddNodeAs(name, fn, nodeOption...)
-}
-
-func (g *AdvancedStateGraph[StateT]) AddNodeAs(name string, fn any, nodeOption ...NodeOption) string {
-	if _, exists := g.nodes[name]; exists {
-		panic(fmt.Sprintf("node `%s` already exists", name))
-	}
-	exec, err := compileNodeExecutor(fn, g.stateType)
-	if err != nil {
-		panic(err)
-	}
-	g.nodes[name] = exec
-	g.nodeOptions[name] = resolveNodeConfig(nodeOption...)
-	return name
-}
-
-func (g *AdvancedStateGraph[StateT]) AddAsyncChannel(name string) {
-	g.asyncChannels = append(g.asyncChannels, name)
-}
-
-func (g *AdvancedStateGraph[StateT]) AddCustomOutputStream(name string) {
-	g.customStreams = append(g.customStreams, name)
-}
-
-func (g *AdvancedStateGraph[StateT]) AddEntryNode(fn any, nodeOption ...NodeOption) string {
-	name := NodeName(fn)
-	return g.AddEntryNodeAs(name, fn, nodeOption...)
-}
-
-func (g *AdvancedStateGraph[StateT]) AddEntryNodeAs(name string, fn any, nodeOption ...NodeOption) string {
-	name = g.AddNodeAs(name, fn, nodeOption...)
-	g.entryPoint = name
-	return name
-}
-
-func (g *AdvancedStateGraph[StateT]) AddFinishNode(fn any, nodeOption ...NodeOption) string {
-	name := NodeName(fn)
-	return g.AddFinishNodeAs(name, fn, nodeOption...)
-}
-
-func (g *AdvancedStateGraph[StateT]) AddFinishNodeAs(name string, fn any, nodeOption ...NodeOption) string {
-	name = g.AddNodeAs(name, fn, nodeOption...)
-	g.finishPoint = name
-	return name
-}
-
-func (g *AdvancedStateGraph[StateT]) Compile() *CompiledGraph[StateT] {
-	return &CompiledGraph[StateT]{
-		nodes:         g.nodes,
-		nodeOptions:   g.nodeOptions,
-		asyncChannels: g.asyncChannels,
-		customStreams: g.customStreams,
-		entryPoint:    g.entryPoint,
-		finishPoint:   g.finishPoint,
-		stateType:     g.stateType,
-	}
-}
-
-type CompiledGraph[StateT any] struct {
-	nodes         map[string]nodeExecutor
-	nodeOptions   map[string]nodeConfig
-	asyncChannels []string
-	customStreams []string
-	entryPoint    string
-	finishPoint   string
-	stateType     reflect.Type
-}
-
-type Context struct {
-	engine      *RustEngine
-	resumeEvent *WaitEvent
-	isResume    bool
-}
-
-func (c *Context) WaitFor(target WaitTarget) (WaitForResult, error) {
-	if target == nil {
-		return WaitForResult{}, fmt.Errorf("wait target cannot be nil")
-	}
-	if c.resumeEvent != nil {
-		event := *c.resumeEvent
-		c.resumeEvent = nil
-		return waitForResultFromRaw(target, event), nil
-	}
-	return WaitForResult{}, ErrWaitRequested{Target: target}
-}
-
-func (c *Context) IsResume() bool {
-	return c.isResume
-}
-
-func (c *Context) PublishToChannel(channel string, value any) error {
-	return c.engine.Publish(channel, value)
-}
-
-func (c *Context) SendCustomStreamEvent(streamName string, value any) error {
-	return c.engine.SendCustomStreamEvent(streamName, value)
-}
-
-type Handler[StateT any] struct {
-	engine       *RustEngine
-	done         chan resultOrErr[StateT]
-	streamReadyC chan struct{}
-}
-
-type resultOrErr[StateT any] struct {
-	state StateT
-	err   error
-}
-
-func (h *Handler[StateT]) PublishToChannel(channel string, value any) error {
-	return h.engine.Publish(channel, value)
-}
-
-func (h *Handler[StateT]) WaitForResult() (StateT, error) {
-	res := <-h.done
-	return res.state, res.err
-}
-
-func (h *Handler[StateT]) ReceiveStream(streamName string) (any, error) {
-	<-h.streamReadyC
-	event, hasEvent, err := h.engine.ReceiveStream(streamName)
-	if err != nil {
-		return nil, err
-	}
-	if !hasEvent {
-		return nil, nil
-	}
-	return event, nil
-}
-
-func (h *Handler[StateT]) CloseAllStreams() error {
-	<-h.streamReadyC
-	return h.engine.CloseAllStreams()
-}
-
-func (g *CompiledGraph[StateT]) Start(initialInput any, initialState StateT, streamMode ...string) (*Handler[StateT], error) {
-	resolvedStreamMode := ""
-	if len(streamMode) > 1 {
-		return nil, fmt.Errorf("start accepts at most one stream mode")
-	}
-	if len(streamMode) == 1 {
-		resolvedStreamMode = streamMode[0]
-	}
-	engine := NewRustEngine()
-	for _, ch := range g.asyncChannels {
-		if err := engine.AddAsyncChannel(ch); err != nil {
-			return nil, err
-		}
-	}
-	for _, streamName := range g.customStreams {
-		if err := engine.AddCustomOutputStream(streamName); err != nil {
-			return nil, err
-		}
-	}
-
-	handler := &Handler[StateT]{
-		engine:       engine,
-		done:         make(chan resultOrErr[StateT], 1),
-		streamReadyC: make(chan struct{}),
-	}
-	go func() {
-		defer engine.Close()
-		streamModeForRun := resolvedStreamMode
-		if resolvedStreamMode != "" {
-			if err := engine.StartStream(resolvedStreamMode); err != nil {
-				close(handler.streamReadyC)
-				handler.done <- resultOrErr[StateT]{err: err}
-				close(handler.done)
-				return
-			}
-			streamModeForRun = ""
-		}
-		close(handler.streamReadyC)
-		rawState, err := engine.RunGraph(
-			g.entryPoint,
-			g.finishPoint,
-			streamModeForRun,
-			initialState,
-			initialInput,
-			g.nodeLockedFields(),
-			func(node string, nodeInput any, fallbackState map[string]any) (Command, error) {
-				fn, ok := g.nodes[node]
-				if !ok {
-					return Command{}, fmt.Errorf("unknown node `%s`", node)
-				}
-				if fallbackState == nil {
-					return Command{}, fmt.Errorf("node `%s` expected map state argument", node)
-				}
-				resolvedInput, resumeEvent := unwrapResumeInput(nodeInput)
-				return fn(
-					&Context{
-						engine:      engine,
-						resumeEvent: resumeEvent,
-						isResume:    resumeEvent != nil,
-					},
-					resolvedInput,
-					fallbackState,
-				)
-			},
-		)
-		if err != nil {
-			handler.done <- resultOrErr[StateT]{err: err}
-			close(handler.done)
-			return
-		}
-		state, err := mapToState[StateT](rawState)
-		handler.done <- resultOrErr[StateT]{state: state, err: err}
-		close(handler.done)
-	}()
-	return handler, nil
-}
-
-func (g *CompiledGraph[StateT]) nodeLockedFields() map[string][]string {
-	result := make(map[string][]string, len(g.nodeOptions))
-	for nodeName, option := range g.nodeOptions {
-		if len(option.lockedFields) == 0 {
-			continue
-		}
-		fields := make([]string, 0, len(option.lockedFields))
-		for _, field := range option.lockedFields {
-			if field == "" {
-				continue
-			}
-			fields = append(fields, field)
-		}
-		if len(fields) > 0 {
-			result[nodeName] = fields
-		}
-	}
-	return result
-}
-
-func resolveNodeConfig(nodeOption ...NodeOption) nodeConfig {
-	cfg := nodeConfig{}
-	for _, option := range nodeOption {
-		if option == nil {
-			panic("node option cannot be nil")
-		}
-		option.applyToNodeConfig(&cfg)
-	}
-	return cfg
-}
-
-func NodeName(fn any) string {
-	rv := reflect.ValueOf(fn)
-	if !rv.IsValid() || rv.Kind() != reflect.Func {
-		panic("cannot infer node name from non-function value")
-	}
-	pc := rv.Pointer()
-	f := runtime.FuncForPC(pc)
-	if f == nil {
-		panic("cannot infer node name from nil function")
-	}
-	full := f.Name()
-	if strings.Contains(full, ".func") {
-		panic("anonymous functions are not allowed as nodes")
-	}
-	short := full
-	if i := strings.LastIndex(short, "/"); i >= 0 {
-		short = short[i+1:]
-	}
-	if i := strings.LastIndex(short, "."); i >= 0 {
-		short = short[i+1:]
-	}
-	short = strings.TrimSuffix(short, "-fm")
-	if short == "" || strings.Contains(short, "func") {
-		panic(fmt.Sprintf("cannot infer stable node name from `%s`", full))
-	}
-	return short
-}
-
-func compileNodeExecutor(fn any, expectedStateType reflect.Type) (nodeExecutor, error) {
-	rv := reflect.ValueOf(fn)
-	if !rv.IsValid() || rv.Kind() != reflect.Func {
-		return nil, fmt.Errorf("node must be a function")
-	}
-	rt := rv.Type()
-	if rt.NumIn() != 3 {
-		return nil, fmt.Errorf("node `%s` must accept exactly 3 args: (*Context, input, state)", NodeName(fn))
-	}
-	ctxType := reflect.TypeOf((*Context)(nil))
-	if rt.In(0) != ctxType {
-		return nil, fmt.Errorf("node `%s` first arg must be *Context", NodeName(fn))
-	}
-	if rt.NumOut() != 2 {
-		return nil, fmt.Errorf("node `%s` must return (Command, error)", NodeName(fn))
-	}
-	cmdType := reflect.TypeOf(Command{})
-	if rt.Out(0) != cmdType {
-		return nil, fmt.Errorf("node `%s` first return must be Command", NodeName(fn))
-	}
-	errType := reflect.TypeOf((*error)(nil)).Elem()
-	if !rt.Out(1).Implements(errType) {
-		return nil, fmt.Errorf("node `%s` second return must be error", NodeName(fn))
-	}
-
-	inputType := rt.In(1)
-	stateType := rt.In(2)
-	if stateType != expectedStateType {
-		return nil, fmt.Errorf(
-			"node `%s` state type mismatch: got %s, graph expects %s",
-			NodeName(fn),
-			stateType.String(),
-			expectedStateType.String(),
-		)
-	}
-	return func(ctx *Context, input any, state map[string]any) (Command, error) {
-		stateArg, err := convertStateArg(state, stateType)
-		if err != nil {
-			return Command{}, fmt.Errorf("node `%s` state decode failed: %w", NodeName(fn), err)
-		}
-		args := []reflect.Value{
-			reflect.ValueOf(ctx),
-			reflect.Zero(inputType),
-			stateArg,
-		}
-		if input != nil {
-			inVal := reflect.ValueOf(input)
-			if inVal.Type().AssignableTo(inputType) {
-				args[1] = inVal
-			} else if inVal.Type().ConvertibleTo(inputType) {
-				args[1] = inVal.Convert(inputType)
-			} else {
-				return Command{}, fmt.Errorf(
-					"node `%s` input type mismatch: got %T, want %s",
-					NodeName(fn),
-					input,
-					inputType.String(),
-				)
-			}
-		}
-		out := rv.Call(args)
-		cmd := out[0].Interface().(Command)
-		if cmd.Update != nil {
-			updateType := reflect.TypeOf(cmd.Update)
-			if updateType != stateType {
-				return Command{}, fmt.Errorf(
-					"node `%s` update type mismatch: got %s, graph expects %s",
-					NodeName(fn),
-					updateType.String(),
-					stateType.String(),
-				)
-			}
-		}
-		if out[1].IsNil() {
-			return cmd, nil
-		}
-		return cmd, out[1].Interface().(error)
-	}, nil
-}
-
-func convertStateArg(state map[string]any, stateType reflect.Type) (reflect.Value, error) {
-	if stateType == reflect.TypeOf(map[string]any{}) {
-		return reflect.ValueOf(state), nil
-	}
-	raw, err := json.Marshal(state)
-	if err != nil {
-		return reflect.Value{}, fmt.Errorf("marshal state: %w", err)
-	}
-	if stateType.Kind() == reflect.Ptr {
-		target := reflect.New(stateType.Elem())
-		if err := json.Unmarshal(raw, target.Interface()); err != nil {
-			return reflect.Value{}, fmt.Errorf("unmarshal state into %s: %w", stateType.String(), err)
-		}
-		return target, nil
-	}
-	target := reflect.New(stateType)
-	if err := json.Unmarshal(raw, target.Interface()); err != nil {
-		return reflect.Value{}, fmt.Errorf("unmarshal state into %s: %w", stateType.String(), err)
-	}
-	return target.Elem(), nil
-}
-
-func mapToState[StateT any](raw map[string]any) (StateT, error) {
-	var out StateT
-	if anyVal, ok := any(raw).(StateT); ok {
-		return anyVal, nil
-	}
-	payload, err := json.Marshal(raw)
-	if err != nil {
-		return out, fmt.Errorf("marshal state: %w", err)
-	}
-	if err := json.Unmarshal(payload, &out); err != nil {
-		return out, fmt.Errorf("unmarshal state: %w", err)
-	}
-	return out, nil
-}
-
-func mustTypeOf[T any]() reflect.Type {
-	var zero T
-	t := reflect.TypeOf(zero)
-	if t != nil {
-		return t
-	}
-	// Handles nil-able types where zero value has no dynamic type.
-	return reflect.TypeOf((*T)(nil)).Elem()
-}
-
-func unwrapResumeInput(input any) (any, *WaitEvent) {
-	wrapper, ok := input.(map[string]any)
-	if !ok {
-		return input, nil
-	}
-	rawArg, hasArg := wrapper["__lg_resume_arg__"]
-	rawEvent, hasEvent := wrapper["__lg_resume_event__"]
-	if !hasArg || !hasEvent {
-		return input, nil
-	}
-	eventPayload, err := json.Marshal(rawEvent)
-	if err != nil {
-		return rawArg, nil
-	}
-	var event WaitEvent
-	if err := json.Unmarshal(eventPayload, &event); err != nil {
-		return rawArg, nil
-	}
-	return rawArg, &event
-}
-
-func waitForResultFromRaw(target WaitTarget, event WaitEvent) WaitForResult {
-	conditions := target.waitConditions()
-	result := WaitForResult{
-		Conditions: make([]ConditionResult, len(conditions)),
-	}
-	if target.waitKind() == "all_of" {
-		for i, cond := range conditions {
-			if isTimerCondition(cond) {
-				result.Conditions[i] = ConditionResult{Met: true}
-			}
-		}
-	}
-
-	if event.Condition == "timer" {
-		for i, cond := range conditions {
-			if isTimerCondition(cond) {
-				result.Conditions[i] = ConditionResult{Met: true}
-				if target.waitKind() == "any_of" {
-					break
-				}
-			}
-		}
-		return result
-	}
-
-	if event.Condition != "channel" {
-		return result
-	}
-
-	if event.Channel == "__any_of__" || event.Channel == "__all_of__" {
-		var matched []struct {
-			Channel string `json:"channel"`
-			Value   any    `json:"value"`
-		}
-		_ = json.Unmarshal(event.Value, &matched)
-		cursor := 0
-		for i, cond := range conditions {
-			channelName, ok := channelNameOfCondition(cond)
-			if !ok || cursor >= len(matched) {
-				continue
-			}
-			if channelName == matched[cursor].Channel {
-				result.Conditions[i] = ConditionResult{
-					Met:         true,
-					ChannelName: channelName,
-					Values:      toValues(matched[cursor].Value),
-				}
-				cursor++
-			}
-		}
-		return result
-	}
-
-	var value any
-	_ = json.Unmarshal(event.Value, &value)
-	for i, cond := range conditions {
-		channelName, ok := channelNameOfCondition(cond)
-		if !ok {
-			continue
-		}
-		if channelName == event.Channel {
-			result.Conditions[i] = ConditionResult{
-				Met:         true,
-				ChannelName: channelName,
-				Values:      toValues(value),
-			}
-			break
-		}
-	}
-	return result
-}
-
-func isTimerCondition(cond WaitCondition) bool {
-	switch cond.(type) {
-	case TimerCondition, *TimerCondition:
-		return true
-	default:
-		return false
-	}
-}
-
-func channelNameOfCondition(cond WaitCondition) (string, bool) {
-	switch c := cond.(type) {
-	case ChannelCondition:
-		return c.Channel, true
-	case *ChannelCondition:
-		if c == nil {
-			return "", false
-		}
-		return c.Channel, true
-	default:
-		return "", false
-	}
-}
-
-func toValues(value any) []any {
-	if value == nil {
-		return []any{}
-	}
-	if vals, ok := value.([]any); ok {
-		return vals
-	}
-	return []any{value}
-}

langgraph-go/advancedgraph/rust_engine.go

@@ -1,456 +0,0 @@
-package advancedgraph
-
-/*
-#cgo CFLAGS: -I${SRCDIR}/../../rust-core/include
-#cgo LDFLAGS: -L${SRCDIR}/../../rust-core/target/debug -llanggraph_rust_core
-#include "langgraph_rust_core.h"
-#include <stdlib.h>
-extern char* goNodeCallback(unsigned long user_data, char* node, char* arg_json, char* state_json);
-static inline char* rc_run_graph_json_with_go_callback(
-    Engine* ptr,
-    const char* entry_point,
-    const char* finish_point,
-    const char* initial_state_json,
-    const char* initial_input_json,
-    const char* stream_mode,
-    const char* node_locked_fields_json,
-    unsigned long user_data
-) {
-    return rc_run_graph_json(
-        ptr,
-        entry_point,
-        finish_point,
-        initial_state_json,
-        initial_input_json,
-        stream_mode,
-        node_locked_fields_json,
-        user_data,
-        goNodeCallback
-    );
-}
-*/
-import "C"
-
-import (
-	"encoding/json"
-	"fmt"
-	"reflect"
-	"sync"
-	"sync/atomic"
-	"unsafe"
-)
-
-type RustEngine struct {
-	ptr *C.Engine
-}
-
-type runGraphCallbackCtx struct {
-	exec func(node string, nodeInput any, state map[string]any) (Command, error)
-}
-
-var (
-	callbackRegistryMu sync.RWMutex
-	callbackRegistry   = map[uint64]*runGraphCallbackCtx{}
-	callbackNextID     uint64
-)
-
-func registerRunGraphCallbackCtx(ctx *runGraphCallbackCtx) uint64 {
-	id := atomic.AddUint64(&callbackNextID, 1)
-	callbackRegistryMu.Lock()
-	callbackRegistry[id] = ctx
-	callbackRegistryMu.Unlock()
-	return id
-}
-
-func unregisterRunGraphCallbackCtx(id uint64) {
-	callbackRegistryMu.Lock()
-	delete(callbackRegistry, id)
-	callbackRegistryMu.Unlock()
-}
-
-func getRunGraphCallbackCtx(id uint64) (*runGraphCallbackCtx, bool) {
-	callbackRegistryMu.RLock()
-	ctx, ok := callbackRegistry[id]
-	callbackRegistryMu.RUnlock()
-	return ctx, ok
-}
-
-//export goNodeCallback
-func goNodeCallback(userData C.ulong, node *C.char, argJSON *C.char, stateJSON *C.char) *C.char {
-	ctx, ok := getRunGraphCallbackCtx(uint64(userData))
-	if !ok {
-		return cCallbackEnvelopeError("invalid callback context (possibly stale callback)")
-	}
-
-	nodeName := C.GoString(node)
-
-	var nodeInput any
-	if err := json.Unmarshal([]byte(C.GoString(argJSON)), &nodeInput); err != nil {
-		return cCallbackEnvelopeError(fmt.Sprintf("decode arg failed for `%s`: %v", nodeName, err))
-	}
-	var state map[string]any
-	if err := json.Unmarshal([]byte(C.GoString(stateJSON)), &state); err != nil {
-		return cCallbackEnvelopeError(fmt.Sprintf("decode state failed for `%s`: %v", nodeName, err))
-	}
-	nodeInput = coerceJSONValue(nodeInput)
-	stateAny := coerceJSONValue(state)
-	state, ok = stateAny.(map[string]any)
-	if !ok {
-		return cCallbackEnvelopeError(fmt.Sprintf("decoded state has unexpected type for `%s`", nodeName))
-	}
-
-	cmd, err := ctx.exec(nodeName, nodeInput, state)
-	if err != nil {
-		if waitReq, ok := AsErrWaitRequested(err); ok {
-			return cCallbackEnvelopeSuspend(waitReq.Target)
-		}
-		return cCallbackEnvelopeError(err.Error())
-	}
-
-	sends := make([]map[string]any, 0, len(cmd.Goto))
-	for _, send := range cmd.Goto {
-		targetNode, err := resolveSendTarget(send.Node)
-		if err != nil {
-			return cCallbackEnvelopeError(err.Error())
-		}
-		sends = append(sends, map[string]any{
-			"node": targetNode,
-			"arg":  send.NodeInput,
-		})
-	}
-	payload := map[string]any{
-		"update": cmd.Update,
-		"sends":  sends,
-	}
-	raw, err := json.Marshal(map[string]any{
-		"ok":      true,
-		"payload": payload,
-	})
-	if err != nil {
-		return cCallbackEnvelopeError(fmt.Sprintf("encode callback payload failed: %v", err))
-	}
-	return C.CString(string(raw))
-}
-
-func NewRustEngine() *RustEngine {
-	return &RustEngine{ptr: C.rc_engine_new()}
-}
-
-func (e *RustEngine) Close() {
-	if e.ptr != nil {
-		C.rc_engine_free(e.ptr)
-		e.ptr = nil
-	}
-}
-
-func (e *RustEngine) AddAsyncChannel(channel string) error {
-	cch := C.CString(channel)
-	defer C.free(unsafe.Pointer(cch))
-	resp := C.rc_add_async_channel(e.ptr, cch)
-	return parseRustStatus(resp)
-}
-
-func (e *RustEngine) AddCustomOutputStream(streamName string) error {
-	cname := C.CString(streamName)
-	defer C.free(unsafe.Pointer(cname))
-	resp := C.rc_add_custom_output_stream(e.ptr, cname)
-	return parseRustStatus(resp)
-}
-
-func (e *RustEngine) StartStream(streamMode string) error {
-	var cmode *C.char
-	if streamMode != "" {
-		cmode = C.CString(streamMode)
-		defer C.free(unsafe.Pointer(cmode))
-	}
-	resp := C.rc_start_stream(e.ptr, cmode)
-	return parseRustStatus(resp)
-}
-
-func (e *RustEngine) ReceiveStream(streamName string) (any, bool, error) {
-	cname := C.CString(streamName)
-	defer C.free(unsafe.Pointer(cname))
-	resp := C.rc_receive_stream_json(e.ptr, cname)
-	defer C.rc_string_free(resp)
-
-	raw := C.GoString(resp)
-	var status struct {
-		OK       bool            `json:"ok"`
-		Error    string          `json:"error"`
-		HasEvent bool            `json:"has_event"`
-		Event    json.RawMessage `json:"event"`
-	}
-	if err := json.Unmarshal([]byte(raw), &status); err != nil {
-		return nil, false, fmt.Errorf("decode rust stream response: %w", err)
-	}
-	if !status.OK {
-		return nil, false, fmt.Errorf("rust stream failed: %s", status.Error)
-	}
-	if !status.HasEvent {
-		return nil, false, nil
-	}
-	var event any
-	if err := json.Unmarshal(status.Event, &event); err != nil {
-		return nil, false, fmt.Errorf("decode stream event: %w", err)
-	}
-	return coerceJSONValue(event), true, nil
-}
-
-func (e *RustEngine) SendCustomStreamEvent(streamName string, value any) error {
-	payload, err := json.Marshal(value)
-	if err != nil {
-		return fmt.Errorf("marshal stream event: %w", err)
-	}
-	cname := C.CString(streamName)
-	cval := C.CString(string(payload))
-	defer C.free(unsafe.Pointer(cname))
-	defer C.free(unsafe.Pointer(cval))
-	resp := C.rc_send_custom_stream_event(e.ptr, cname, cval)
-	return parseRustStatus(resp)
-}
-
-func (e *RustEngine) CloseAllStreams() error {
-	resp := C.rc_close_all_streams(e.ptr)
-	return parseRustStatus(resp)
-}
-
-func (e *RustEngine) Publish(channel string, value any) error {
-	payload, err := json.Marshal(value)
-	if err != nil {
-		return fmt.Errorf("marshal publish value: %w", err)
-	}
-	cch := C.CString(channel)
-	cval := C.CString(string(payload))
-	defer C.free(unsafe.Pointer(cch))
-	defer C.free(unsafe.Pointer(cval))
-	resp := C.rc_publish_json(e.ptr, cch, cval)
-	return parseRustStatus(resp)
-}
-
-func (e *RustEngine) WaitAnyOf(cond AnyOfCondition) (WaitEvent, error) {
-	payload, err := json.Marshal(cond)
-	if err != nil {
-		return WaitEvent{}, fmt.Errorf("marshal any_of: %w", err)
-	}
-	cpayload := C.CString(string(payload))
-	defer C.free(unsafe.Pointer(cpayload))
-	resp := C.rc_wait_any_of_json(e.ptr, cpayload)
-	defer C.rc_string_free(resp)
-
-	raw := C.GoString(resp)
-	var status struct {
-		OK    bool            `json:"ok"`
-		Error string          `json:"error"`
-		Event json.RawMessage `json:"event"`
-	}
-	if err := json.Unmarshal([]byte(raw), &status); err != nil {
-		return WaitEvent{}, fmt.Errorf("decode rust wait response: %w", err)
-	}
-	if !status.OK {
-		return WaitEvent{}, fmt.Errorf("rust wait failed: %s", status.Error)
-	}
-	var event WaitEvent
-	if err := json.Unmarshal(status.Event, &event); err != nil {
-		return WaitEvent{}, fmt.Errorf("decode wait event: %w", err)
-	}
-	return event, nil
-}
-
-func (e *RustEngine) WaitAllOf(cond AllOfCondition) (WaitEvent, error) {
-	payload, err := json.Marshal(cond)
-	if err != nil {
-		return WaitEvent{}, fmt.Errorf("marshal all_of: %w", err)
-	}
-	cpayload := C.CString(string(payload))
-	defer C.free(unsafe.Pointer(cpayload))
-	resp := C.rc_wait_all_of_json(e.ptr, cpayload)
-	defer C.rc_string_free(resp)
-
-	raw := C.GoString(resp)
-	var status struct {
-		OK    bool            `json:"ok"`
-		Error string          `json:"error"`
-		Event json.RawMessage `json:"event"`
-	}
-	if err := json.Unmarshal([]byte(raw), &status); err != nil {
-		return WaitEvent{}, fmt.Errorf("decode rust wait response: %w", err)
-	}
-	if !status.OK {
-		return WaitEvent{}, fmt.Errorf("rust wait failed: %s", status.Error)
-	}
-	var event WaitEvent
-	if err := json.Unmarshal(status.Event, &event); err != nil {
-		return WaitEvent{}, fmt.Errorf("decode wait event: %w", err)
-	}
-	return event, nil
-}
-
-func (e *RustEngine) RunGraph(
-	entryPoint string,
-	finishPoint string,
-	streamMode string,
-	initialState any,
-	initialInput any,
-	nodeLockedFields map[string][]string,
-	exec func(node string, nodeInput any, state map[string]any) (Command, error),
-) (map[string]any, error) {
-	initialJSON, err := json.Marshal(initialState)
-	if err != nil {
-		return nil, fmt.Errorf("marshal initial state: %w", err)
-	}
-	initialInputJSON, err := json.Marshal(initialInput)
-	if err != nil {
-		return nil, fmt.Errorf("marshal initial input: %w", err)
-	}
-	lockedFieldsJSON, err := json.Marshal(nodeLockedFields)
-	if err != nil {
-		return nil, fmt.Errorf("marshal node locked fields: %w", err)
-	}
-	centry := C.CString(entryPoint)
-	cfinish := C.CString(finishPoint)
-	cinitial := C.CString(string(initialJSON))
-	cinitialInput := C.CString(string(initialInputJSON))
-	clockedFields := C.CString(string(lockedFieldsJSON))
-	var cstreamMode *C.char
-	if streamMode != "" {
-		cstreamMode = C.CString(streamMode)
-	}
-	defer C.free(unsafe.Pointer(centry))
-	defer C.free(unsafe.Pointer(cfinish))
-	defer C.free(unsafe.Pointer(cinitial))
-	defer C.free(unsafe.Pointer(cinitialInput))
-	defer C.free(unsafe.Pointer(clockedFields))
-	if cstreamMode != nil {
-		defer C.free(unsafe.Pointer(cstreamMode))
-	}
-
-	callbackID := registerRunGraphCallbackCtx(&runGraphCallbackCtx{exec: exec})
-	defer unregisterRunGraphCallbackCtx(callbackID)
-
-	resp := C.rc_run_graph_json_with_go_callback(
-		e.ptr,
-		centry,
-		cfinish,
-		cinitial,
-		cinitialInput,
-		cstreamMode,
-		clockedFields,
-		C.ulong(callbackID),
-	)
-	defer C.rc_string_free(resp)
-
-	raw := C.GoString(resp)
-	var status struct {
-		OK    bool           `json:"ok"`
-		Error string         `json:"error"`
-		State map[string]any `json:"state"`
-	}
-	if err := json.Unmarshal([]byte(raw), &status); err != nil {
-		return nil, fmt.Errorf("decode rust run response: %w", err)
-	}
-	if !status.OK {
-		return nil, fmt.Errorf("rust run failed: %s", status.Error)
-	}
-	coerced := coerceJSONValue(status.State)
-	typed, ok := coerced.(map[string]any)
-	if !ok {
-		return nil, fmt.Errorf("unexpected state type from rust run")
-	}
-	return typed, nil
-}
-
-func cCallbackEnvelopeError(message string) *C.char {
-	raw, _ := json.Marshal(map[string]any{
-		"ok":    false,
-		"error": message,
-	})
-	return C.CString(string(raw))
-}
-
-func cCallbackEnvelopeSuspend(target WaitTarget) *C.char {
-	if target == nil {
-		return cCallbackEnvelopeError("wait requested with nil target")
-	}
-	kind := target.waitKind()
-	if kind != "any_of" && kind != "all_of" {
-		return cCallbackEnvelopeError(fmt.Sprintf("unsupported wait target kind `%s`", kind))
-	}
-	var payload map[string]any
-	if kind == "any_of" {
-		payload = map[string]any{
-			"kind":   "any_of",
-			"any_of": AnyOfCondition{Conditions: target.waitConditions()},
-		}
-	} else {
-		payload = map[string]any{
-			"kind":   "all_of",
-			"all_of": AllOfCondition{Conditions: target.waitConditions()},
-		}
-	}
-	raw, _ := json.Marshal(map[string]any{
-		"ok":      true,
-		"suspend": payload,
-	})
-	return C.CString(string(raw))
-}
-
-func resolveSendTarget(target any) (string, error) {
-	if name, ok := target.(string); ok {
-		if name == "" {
-			return "", fmt.Errorf("send target cannot be empty string")
-		}
-		return name, nil
-	}
-	rv := reflect.ValueOf(target)
-	if rv.IsValid() && rv.Kind() == reflect.Func {
-		return NodeName(target), nil
-	}
-	return "", fmt.Errorf("unsupported send target type %T", target)
-}
-
-func coerceJSONValue(v any) any {
-	switch t := v.(type) {
-	case map[string]any:
-		out := make(map[string]any, len(t))
-		for k, val := range t {
-			out[k] = coerceJSONValue(val)
-		}
-		return out
-	case []any:
-		coerced := make([]any, len(t))
-		allStrings := true
-		for i, val := range t {
-			cv := coerceJSONValue(val)
-			coerced[i] = cv
-			if _, ok := cv.(string); !ok {
-				allStrings = false
-			}
-		}
-		if allStrings {
-			out := make([]string, len(coerced))
-			for i, item := range coerced {
-				out[i] = item.(string)
-			}
-			return out
-		}
-		return coerced
-	default:
-		return v
-	}
-}
-
-func parseRustStatus(resp *C.char) error {
-	defer C.rc_string_free(resp)
-	raw := C.GoString(resp)
-	var status struct {
-		OK    bool   `json:"ok"`
-		Error string `json:"error"`
-	}
-	if err := json.Unmarshal([]byte(raw), &status); err != nil {
-		return fmt.Errorf("decode rust response: %w", err)
-	}
-	if !status.OK {
-		return fmt.Errorf("rust error: %s", status.Error)
-	}
-	return nil
-}

langgraph-go/advancedgraph/types.go

@@ -1,191 +0,0 @@
-package advancedgraph
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"reflect"
-)
-
-type WaitCondition interface {
-	json.Marshaler
-}
-
-type ChannelCondition struct {
-	Channel string
-	Min     int
-	Max     int
-}
-
-type channelConditionJSON struct {
-	Kind    string `json:"kind"`
-	Channel string `json:"channel"`
-	Min     int    `json:"min"`
-	Max     int    `json:"max"`
-}
-
-func (c ChannelCondition) MarshalJSON() ([]byte, error) {
-	min := c.Min
-	if min <= 0 {
-		min = 1
-	}
-	return json.Marshal(channelConditionJSON{
-		Kind:    "channel",
-		Channel: c.Channel,
-		Min:     min,
-		Max:     c.Max,
-	})
-}
-
-type TimerCondition struct {
-	Seconds float64
-}
-
-type timerConditionJSON struct {
-	Kind    string  `json:"kind"`
-	Seconds float64 `json:"seconds"`
-}
-
-func (t TimerCondition) MarshalJSON() ([]byte, error) {
-	return json.Marshal(timerConditionJSON{
-		Kind:    "timer",
-		Seconds: t.Seconds,
-	})
-}
-
-type AnyOfCondition struct {
-	Conditions []WaitCondition
-}
-
-type AllOfCondition struct {
-	Conditions []WaitCondition
-}
-
-type WaitTarget interface {
-	waitKind() string
-	waitConditions() []WaitCondition
-}
-
-func (a AnyOfCondition) waitKind() string {
-	return "any_of"
-}
-
-func (a AnyOfCondition) waitConditions() []WaitCondition {
-	return a.Conditions
-}
-
-func (a AllOfCondition) waitKind() string {
-	return "all_of"
-}
-
-func (a AllOfCondition) waitConditions() []WaitCondition {
-	return a.Conditions
-}
-
-func AnyOf(conditions ...WaitCondition) AnyOfCondition {
-	return AnyOfCondition{Conditions: append([]WaitCondition{}, conditions...)}
-}
-
-func AllOf(conditions ...WaitCondition) AllOfCondition {
-	return AllOfCondition{Conditions: append([]WaitCondition{}, conditions...)}
-}
-
-func (a AnyOfCondition) MarshalJSON() ([]byte, error) {
-	result := struct {
-		Conditions []json.RawMessage `json:"conditions"`
-	}{
-		Conditions: make([]json.RawMessage, 0, len(a.Conditions)),
-	}
-	for i, cond := range a.Conditions {
-		if isNilWaitCondition(cond) {
-			return nil, fmt.Errorf("any_of condition[%d] is nil", i)
-		}
-		raw, err := cond.MarshalJSON()
-		if err != nil {
-			return nil, fmt.Errorf("encode any_of condition[%d]: %w", i, err)
-		}
-		result.Conditions = append(result.Conditions, json.RawMessage(raw))
-	}
-	return json.Marshal(result)
-}
-
-func (a AllOfCondition) MarshalJSON() ([]byte, error) {
-	result := struct {
-		Conditions []json.RawMessage `json:"conditions"`
-	}{
-		Conditions: make([]json.RawMessage, 0, len(a.Conditions)),
-	}
-	for i, cond := range a.Conditions {
-		if isNilWaitCondition(cond) {
-			return nil, fmt.Errorf("all_of condition[%d] is nil", i)
-		}
-		raw, err := cond.MarshalJSON()
-		if err != nil {
-			return nil, fmt.Errorf("encode all_of condition[%d]: %w", i, err)
-		}
-		result.Conditions = append(result.Conditions, json.RawMessage(raw))
-	}
-	return json.Marshal(result)
-}
-
-func isNilWaitCondition(cond WaitCondition) bool {
-	if cond == nil {
-		return true
-	}
-	v := reflect.ValueOf(cond)
-	switch v.Kind() {
-	case reflect.Ptr, reflect.Interface, reflect.Slice, reflect.Map, reflect.Func:
-		return v.IsNil()
-	default:
-		return false
-	}
-}
-
-type WaitEvent struct {
-	Condition string          `json:"condition"`
-	Channel   string          `json:"channel,omitempty"`
-	Value     json.RawMessage `json:"value,omitempty"`
-	Seconds   float64         `json:"seconds,omitempty"`
-}
-
-type ConditionResult struct {
-	Met         bool   `json:"met"`
-	ChannelName string `json:"channel_name,omitempty"`
-	Values      []any  `json:"values,omitempty"`
-}
-
-type WaitForResult struct {
-	Conditions []ConditionResult `json:"conditions"`
-}
-
-type Send struct {
-	Node      any
-	NodeInput any
-}
-
-type Command struct {
-	Update any
-	Goto   []Send
-}
-
-type ErrWaitRequested struct {
-	Target WaitTarget
-}
-
-func (e ErrWaitRequested) Error() string {
-	return "wait requested"
-}
-
-func AsErrWaitRequested(err error) (ErrWaitRequested, bool) {
-	var target ErrWaitRequested
-	if !errors.As(err, &target) {
-		return target, false
-	}
-	return target, true
-}
-
-func DecodeString(raw json.RawMessage) string {
-	var s string
-	_ = json.Unmarshal(raw, &s)
-	return s
-}

langgraph-go/go.mod

@@ -1,3 +0,0 @@
-module github.com/langchain-ai/langgraph/langgraph-go
-
-go 1.25

langgraph-go/stategraph/state_graph.go

@@ -1,329 +0,0 @@
-package stategraph
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"slices"
-
-	ag "github.com/langchain-ai/langgraph/langgraph-go/advancedgraph"
-)
-
-type StateNodeFunc[StateT any] func(ctx *Context, state StateT) (StateT, error)
-
-const (
-	internalBarrierChannel   = "__stategraph_barrier"
-	internalInterruptChannel = "__stategraph_interrupt"
-)
-
-type Context struct {
-	inner *ag.Context
-}
-
-func (c *Context) Interrupt(name string) (any, error) {
-	if name == "" {
-		return nil, fmt.Errorf("interrupt name cannot be empty")
-	}
-	event, err := c.inner.WaitFor(ag.AnyOf(ag.ChannelCondition{
-		Channel: internalInterruptChannel,
-		Min:     1,
-	}))
-	if err != nil {
-		if waitReq, ok := ag.AsErrWaitRequested(err); ok {
-			return nil, errInterruptRequested{
-				Name:      name,
-				Condition: waitReq.Target,
-			}
-		}
-		return nil, err
-	}
-	if len(event.Conditions) == 0 || !event.Conditions[0].Met {
-		return nil, nil
-	}
-	values := event.Conditions[0].Values
-	if len(values) == 0 {
-		return nil, nil
-	}
-	rawValue := values[0]
-	valueBytes, err := json.Marshal(rawValue)
-	if err != nil {
-		return nil, fmt.Errorf("encode interrupt `%s` value: %w", name, err)
-	}
-
-	var payload interruptPayload
-	if err := json.Unmarshal(valueBytes, &payload); err != nil {
-		var value any
-		if err := json.Unmarshal(valueBytes, &value); err != nil {
-			return nil, fmt.Errorf("decode interrupt `%s` value: %w", name, err)
-		}
-		return value, nil
-	}
-	if payload.Name != "" && payload.Name != name {
-		return nil, fmt.Errorf("interrupt name mismatch: expected `%s`, got `%s`", name, payload.Name)
-	}
-	if len(payload.Value) == 0 {
-		return nil, nil
-	}
-	var value any
-	if err := json.Unmarshal(payload.Value, &value); err != nil {
-		return nil, fmt.Errorf("decode interrupt `%s` payload: %w", name, err)
-	}
-	return value, nil
-}
-
-type errInterruptRequested struct {
-	Name      string
-	Condition ag.WaitTarget
-}
-
-func (e errInterruptRequested) Error() string {
-	if e.Name == "" {
-		return "interrupt requested"
-	}
-	return fmt.Sprintf("interrupt requested: %s", e.Name)
-}
-
-func asErrInterruptRequested(err error) (errInterruptRequested, bool) {
-	var target errInterruptRequested
-	if !errors.As(err, &target) {
-		return target, false
-	}
-	return target, true
-}
-
-type BasicStateGraph[StateT any] struct {
-	nodes map[string]StateNodeFunc[StateT]
-	edges map[string][]string
-}
-
-type interruptPayload struct {
-	Name  string          `json:"name"`
-	Value json.RawMessage `json:"value"`
-}
-
-func NewBasicStateGraph[StateT any]() *BasicStateGraph[StateT] {
-	return &BasicStateGraph[StateT]{
-		nodes: make(map[string]StateNodeFunc[StateT]),
-		edges: make(map[string][]string),
-	}
-}
-
-func (g *BasicStateGraph[StateT]) AddNode(fn StateNodeFunc[StateT]) string {
-	name := ag.NodeName(fn)
-	if _, exists := g.nodes[name]; exists {
-		panic(fmt.Sprintf("node `%s` already exists", name))
-	}
-	g.nodes[name] = fn
-	return name
-}
-
-func (g *BasicStateGraph[StateT]) AddEdge(from StateNodeFunc[StateT], to StateNodeFunc[StateT]) {
-	fromName := ag.NodeName(from)
-	toName := ag.NodeName(to)
-	if _, ok := g.nodes[fromName]; !ok {
-		panic(fmt.Sprintf("source node `%s` does not exist", fromName))
-	}
-	if _, ok := g.nodes[toName]; !ok {
-		panic(fmt.Sprintf("target node `%s` does not exist", toName))
-	}
-	g.edges[fromName] = append(g.edges[fromName], toName)
-}
-
-type CompiledBasicStateGraph[StateT any] struct {
-	inner *ag.CompiledGraph[StateT]
-}
-
-type Handler[StateT any] struct {
-	inner *ag.Handler[StateT]
-}
-
-func (h *Handler[StateT]) WaitForResult() (StateT, error) {
-	return h.inner.WaitForResult()
-}
-
-func (h *Handler[StateT]) Resume(name string, value any) error {
-	if name == "" {
-		return fmt.Errorf("interrupt name cannot be empty")
-	}
-	return h.inner.PublishToChannel(internalInterruptChannel, map[string]any{
-		"name":  name,
-		"value": value,
-	})
-}
-
-func (g *BasicStateGraph[StateT]) Compile() *CompiledBasicStateGraph[StateT] {
-	if len(g.nodes) == 0 {
-		panic("graph has no nodes")
-	}
-	levels, err := g.computeSupersteps()
-	if err != nil {
-		panic(err)
-	}
-	adv := ag.NewAdvancedStateGraph[StateT]()
-	adv.AddAsyncChannel(internalBarrierChannel)
-	adv.AddAsyncChannel(internalInterruptChannel)
-
-	const finalNodeName = "__stategraph_finish"
-	finalNode := func(_ *ag.Context, _ any, state StateT) (ag.Command, error) {
-		return ag.Command{Update: state}, nil
-	}
-	adv.AddFinishNodeAs(finalNodeName, finalNode)
-
-	for stepIdx, stepNodes := range levels {
-		for _, nodeName := range stepNodes {
-			userFn := g.nodes[nodeName]
-			nextBarrier := fmt.Sprintf("__stategraph_barrier_%d", stepIdx+1)
-			wrapper := func(ctx *ag.Context, _ any, state StateT) (ag.Command, error) {
-				updated, err := userFn(&Context{inner: ctx}, state)
-				if err != nil {
-					if interruptReq, ok := asErrInterruptRequested(err); ok {
-						cond := interruptReq.Condition
-						if cond == nil {
-							cond = ag.AnyOf(ag.ChannelCondition{
-								Channel: internalInterruptChannel,
-								Min:     1,
-							})
-						}
-						return ag.Command{}, ag.ErrWaitRequested{Target: cond}
-					}
-					return ag.Command{}, err
-				}
-				if err := ctx.PublishToChannel(internalBarrierChannel, map[string]any{
-					"step": stepIdx,
-				}); err != nil {
-					return ag.Command{}, err
-				}
-				return ag.Command{
-					Update: updated,
-					Goto:   []ag.Send{{Node: nextBarrier}},
-				}, nil
-			}
-			adv.AddNodeAs(fmt.Sprintf("__stategraph_node_%s", nodeName), wrapper)
-		}
-	}
-
-	lastBarrier := len(levels)
-	for barrierStep := 0; barrierStep <= lastBarrier; barrierStep++ {
-		barrierName := fmt.Sprintf("__stategraph_barrier_%d", barrierStep)
-		nextStep := barrierStep
-		barrier := func(ctx *ag.Context, _ any, state StateT) (ag.Command, error) {
-			if nextStep > 0 {
-				needed := len(levels[nextStep-1])
-				_, err := ctx.WaitFor(ag.AnyOf(ag.ChannelCondition{
-					Channel: internalBarrierChannel,
-					Min:     needed,
-				}))
-				if err != nil {
-					return ag.Command{}, err
-				}
-			}
-			if nextStep >= len(levels) {
-				return ag.Command{
-					Update: state,
-					Goto:   []ag.Send{{Node: finalNodeName}},
-				}, nil
-			}
-			sends := make([]ag.Send, 0, len(levels[nextStep]))
-			for _, nodeName := range levels[nextStep] {
-				sends = append(sends, ag.Send{
-					Node: fmt.Sprintf("__stategraph_node_%s", nodeName),
-				})
-			}
-			return ag.Command{
-				Update: state,
-				Goto:   sends,
-			}, nil
-		}
-		if barrierStep == 0 {
-			adv.AddEntryNodeAs(barrierName, barrier)
-		} else {
-			adv.AddNodeAs(barrierName, barrier)
-		}
-	}
-
-	return &CompiledBasicStateGraph[StateT]{
-		inner: adv.Compile(),
-	}
-}
-
-func (g *CompiledBasicStateGraph[StateT]) Start(initialState StateT) (*Handler[StateT], error) {
-	raw, err := g.inner.Start(nil, initialState)
-	if err != nil {
-		return nil, err
-	}
-	return &Handler[StateT]{inner: raw}, nil
-}
-
-func (g *CompiledBasicStateGraph[StateT]) Invoke(initialState StateT) (StateT, error) {
-	handler, err := g.Start(initialState)
-	if err != nil {
-		var zero StateT
-		return zero, err
-	}
-	return handler.WaitForResult()
-}
-
-func (g *BasicStateGraph[StateT]) computeSupersteps() ([][]string, error) {
-	indegree := make(map[string]int, len(g.nodes))
-	for name := range g.nodes {
-		indegree[name] = 0
-	}
-	for from, tos := range g.edges {
-		if _, ok := g.nodes[from]; !ok {
-			return nil, fmt.Errorf("edge source `%s` does not exist", from)
-		}
-		for _, to := range tos {
-			if _, ok := g.nodes[to]; !ok {
-				return nil, fmt.Errorf("edge target `%s` does not exist", to)
-			}
-			indegree[to]++
-		}
-	}
-
-	queue := make([]string, 0, len(g.nodes))
-	level := make(map[string]int, len(g.nodes))
-	for name, deg := range indegree {
-		if deg == 0 {
-			queue = append(queue, name)
-		}
-	}
-	if len(queue) == 0 {
-		return nil, fmt.Errorf("graph has no entry nodes (cycle suspected)")
-	}
-
-	processed := 0
-	for len(queue) > 0 {
-		curr := queue[0]
-		queue = queue[1:]
-		processed++
-		currLevel := level[curr]
-		for _, to := range g.edges[curr] {
-			if level[to] < currLevel+1 {
-				level[to] = currLevel + 1
-			}
-			indegree[to]--
-			if indegree[to] == 0 {
-				queue = append(queue, to)
-			}
-		}
-	}
-	if processed != len(g.nodes) {
-		return nil, fmt.Errorf("graph contains a cycle")
-	}
-
-	maxLevel := 0
-	for _, lv := range level {
-		if lv > maxLevel {
-			maxLevel = lv
-		}
-	}
-	levels := make([][]string, maxLevel+1)
-	for nodeName := range g.nodes {
-		lv := level[nodeName]
-		levels[lv] = append(levels[lv], nodeName)
-	}
-	for i := range levels {
-		slices.Sort(levels[i])
-	}
-	return levels, nil
-}

langgraph-go/stategraph/state_graph_test.go

@@ -1,218 +0,0 @@
-package stategraph_test
-
-import (
-	"fmt"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	sg "github.com/langchain-ai/langgraph/langgraph-go/stategraph"
-)
-
-type stateGraphState struct {
-	Noop bool `json:"noop"`
-}
-
-type orderRecorder struct {
-	mu     sync.Mutex
-	orders map[string]int32
-	seq    int32
-}
-
-func newOrderRecorder() *orderRecorder {
-	return &orderRecorder{orders: make(map[string]int32)}
-}
-
-func (f *orderRecorder) record(name string) {
-	idx := atomic.AddInt32(&f.seq, 1)
-	f.mu.Lock()
-	f.orders[name] = idx
-	f.mu.Unlock()
-}
-
-type orderGraph struct {
-	recorder *orderRecorder
-}
-
-func newOrderGraph() *orderGraph {
-	return &orderGraph{
-		recorder: newOrderRecorder(),
-	}
-}
-
-func (g *orderGraph) A(_ *sg.Context, state stateGraphState) (stateGraphState, error) {
-	g.recorder.record("A")
-	return state, nil
-}
-
-func (g *orderGraph) B1(_ *sg.Context, state stateGraphState) (stateGraphState, error) {
-	g.recorder.record("B1")
-	return state, nil
-}
-
-func (g *orderGraph) B2(_ *sg.Context, state stateGraphState) (stateGraphState, error) {
-	g.recorder.record("B2")
-	return state, nil
-}
-
-func (g *orderGraph) C1(_ *sg.Context, state stateGraphState) (stateGraphState, error) {
-	g.recorder.record("C1")
-	return state, nil
-}
-
-func (g *orderGraph) C2(_ *sg.Context, state stateGraphState) (stateGraphState, error) {
-	g.recorder.record("C2")
-	return state, nil
-}
-
-func (g *orderGraph) C3(_ *sg.Context, state stateGraphState) (stateGraphState, error) {
-	g.recorder.record("C3")
-	return state, nil
-}
-
-func (g *orderGraph) D(_ *sg.Context, state stateGraphState) (stateGraphState, error) {
-	g.recorder.record("D")
-	return state, nil
-}
-
-func TestBasicStateGraphWithoutInterrupt(t *testing.T) {
-	fixture := newOrderGraph()
-	graph := sg.NewBasicStateGraph[stateGraphState]()
-	graph.AddNode(fixture.A)
-	graph.AddNode(fixture.B1)
-	graph.AddNode(fixture.B2)
-	graph.AddNode(fixture.C1)
-	graph.AddNode(fixture.C2)
-	graph.AddNode(fixture.C3)
-	graph.AddNode(fixture.D)
-
-	graph.AddEdge(fixture.A, fixture.B1)
-	graph.AddEdge(fixture.A, fixture.B2)
-	graph.AddEdge(fixture.B1, fixture.C1)
-	graph.AddEdge(fixture.B1, fixture.C2)
-	graph.AddEdge(fixture.B2, fixture.C3)
-	graph.AddEdge(fixture.C1, fixture.D)
-	graph.AddEdge(fixture.C2, fixture.D)
-	graph.AddEdge(fixture.C3, fixture.D)
-
-	_, err := graph.Compile().Invoke(stateGraphState{})
-	if err != nil {
-		t.Fatalf("invoke failed: %v", err)
-	}
-
-	fixture.recorder.mu.Lock()
-	orders := make(map[string]int32, len(fixture.recorder.orders))
-	for k, v := range fixture.recorder.orders {
-		orders[k] = v
-	}
-	fixture.recorder.mu.Unlock()
-
-	for _, name := range []string{"A", "B1", "B2", "C1", "C2", "C3", "D"} {
-		if _, ok := orders[name]; !ok {
-			t.Fatalf("node %s did not execute; orders=%v", name, orders)
-		}
-	}
-	maxB := maxInt32(orders["B1"], orders["B2"])
-	minC := minInt32(orders["C1"], minInt32(orders["C2"], orders["C3"]))
-	maxC := maxInt32(orders["C1"], maxInt32(orders["C2"], orders["C3"]))
-	if !(orders["A"] < orders["B1"] && orders["A"] < orders["B2"]) {
-		t.Fatalf("A should run before B-step, orders=%v", orders)
-	}
-	if !(maxB < minC) {
-		t.Fatalf("B-step should finish before C-step, orders=%v", orders)
-	}
-	if !(maxC < orders["D"]) {
-		t.Fatalf("C-step should finish before D, orders=%v", orders)
-	}
-}
-
-type interruptState struct {
-	A bool `json:"a"`
-	B bool `json:"b"`
-}
-
-type interruptFixture struct{}
-
-func (f *interruptFixture) A(_ *sg.Context, state interruptState) (interruptState, error) {
-	state.A = true
-	return state, nil
-}
-
-func (f *interruptFixture) B(ctx *sg.Context, state interruptState) (interruptState, error) {
-	if !state.A {
-		return state, fmt.Errorf("B should observe A=true")
-	}
-	value, err := ctx.Interrupt("resume_channel")
-	if err != nil {
-		return state, err
-	}
-	s, ok := value.(string)
-	if !ok || s != "go" {
-		return state, fmt.Errorf("unexpected interrupt payload: %#v", value)
-	}
-	state.B = true
-	return state, nil
-}
-
-func TestBasicStateGraphWithInterrupt(t *testing.T) {
-	fixture := &interruptFixture{}
-	graph := sg.NewBasicStateGraph[interruptState]()
-	graph.AddNode(fixture.A)
-	graph.AddNode(fixture.B)
-	graph.AddEdge(fixture.A, fixture.B)
-
-	handler, err := graph.Compile().Start(interruptState{})
-	if err != nil {
-		t.Fatalf("start failed: %v", err)
-	}
-
-	doneCh := make(chan interruptState, 1)
-	errCh := make(chan error, 1)
-	go func() {
-		result, runErr := handler.WaitForResult()
-		if runErr != nil {
-			errCh <- runErr
-			return
-		}
-		doneCh <- result
-	}()
-
-	select {
-	case <-doneCh:
-		t.Fatalf("run should pause for interrupt, but completed early")
-	case err := <-errCh:
-		t.Fatalf("run should pause for interrupt, but failed early: %v", err)
-	case <-time.After(120 * time.Millisecond):
-		// expected: paused
-	}
-
-	if err := handler.Resume("resume_channel", "go"); err != nil {
-		t.Fatalf("resume interrupt failed: %v", err)
-	}
-
-	select {
-	case err := <-errCh:
-		t.Fatalf("run failed after interrupt: %v", err)
-	case result := <-doneCh:
-		if !(result.A && result.B) {
-			t.Fatalf("unexpected final state: %#v", result)
-		}
-	case <-time.After(2 * time.Second):
-		t.Fatalf("timeout waiting for resumed run completion")
-	}
-}
-
-func minInt32(a int32, b int32) int32 {
-	if a < b {
-		return a
-	}
-	return b
-}
-
-func maxInt32(a int32, b int32) int32 {
-	if a > b {
-		return a
-	}
-	return b
-}

langgraph-go/tests/sub_agents_test.go

@@ -1,213 +0,0 @@
-package tests
-
-import (
-	"slices"
-	"testing"
-	"time"
-
-	ag "github.com/langchain-ai/langgraph/langgraph-go/advancedgraph"
-)
-
-type decision struct {
-	Type     string
-	SubAgent string
-	Tool     string
-	Complete string
-}
-
-type mockLLM struct {
-	responses [][]decision
-	i         int
-}
-
-func (m *mockLLM) invoke() []decision {
-	if m.i >= len(m.responses) {
-		return []decision{}
-	}
-	resp := m.responses[m.i]
-	m.i++
-	return resp
-}
-
-type lunchWorkflow struct {
-	planner *mockLLM
-}
-
-type lunchState struct {
-	Input  string   `json:"input"`
-	Output []string `json:"output"`
-	Done   string   `json:"done"`
-}
-
-func (w *lunchWorkflow) llmNode(ctx *ag.Context, _ any, _ lunchState) (ag.Command, error) {
-	decisions := w.planner.invoke()
-	sends := make([]ag.Send, 0, 4)
-	for _, d := range decisions {
-		if d.Type == "end" {
-			return ag.Command{
-				Goto: []ag.Send{
-					{Node: w.orderFoodNode, NodeInput: d.Complete},
-				},
-			}, nil
-		}
-		if d.Type == "sub_agent" {
-			sends = append(sends, ag.Send{Node: w.subAgentNode, NodeInput: d.SubAgent})
-		}
-		if d.Type == "tool" {
-			sends = append(sends, ag.Send{Node: w.toolNode, NodeInput: d.Tool})
-		}
-	}
-	sends = append(sends, ag.Send{Node: w.waitNode})
-	return ag.Command{Goto: sends}, nil
-}
-
-func (w *lunchWorkflow) waitNode(ctx *ag.Context, _ any, state lunchState) (ag.Command, error) {
-	event, err := ctx.WaitFor(
-		ag.AnyOf(
-			ag.ChannelCondition{Channel: "tool_completion_channel"},
-			ag.ChannelCondition{Channel: "subagent_completion_channel"},
-			ag.ChannelCondition{Channel: "user_input_channel"},
-			ag.TimerCondition{Seconds: 1},
-		),
-	)
-	if err != nil {
-		return ag.Command{}, err
-	}
-
-	output := append([]string(nil), state.Output...)
-	hadChannel := false
-	for _, cond := range event.Conditions {
-		if !cond.Met || cond.ChannelName == "" {
-			continue
-		}
-		for _, raw := range cond.Values {
-			payload, _ := raw.(string)
-			switch cond.ChannelName {
-			case "tool_completion_channel":
-				output = append(output, "tool: "+payload)
-			case "subagent_completion_channel":
-				output = append(output, "sub_agent: "+payload)
-			case "user_input_channel":
-				output = append(output, "user_input: "+payload)
-			}
-		}
-		hadChannel = true
-	}
-	if hadChannel {
-		state.Output = output
-		return ag.Command{Goto: []ag.Send{{Node: w.llmNode}}, Update: state}, nil
-	}
-
-	output = append(output, "timer: no updates yet")
-	state.Output = output
-	return ag.Command{Goto: []ag.Send{{Node: w.waitNode}}, Update: state}, nil
-}
-
-func (w *lunchWorkflow) toolNode(ctx *ag.Context, input any, _ lunchState) (ag.Command, error) {
-	toolInput, _ := input.(string)
-	time.Sleep(100 * time.Millisecond)
-	err := ctx.PublishToChannel("tool_completion_channel", "tool completed for: "+toolInput)
-	return ag.Command{}, err
-}
-
-func (w *lunchWorkflow) subAgentNode(ctx *ag.Context, input any, _ lunchState) (ag.Command, error) {
-	subInput, _ := input.(string)
-	time.Sleep(5 * time.Second)
-	err := ctx.PublishToChannel(
-		"subagent_completion_channel",
-		"research sub agent completed for: "+subInput,
-	)
-	return ag.Command{}, err
-}
-
-func (w *lunchWorkflow) orderFoodNode(ctx *ag.Context, input any, state lunchState) (ag.Command, error) {
-	complete, _ := input.(string)
-	output := append([]string(nil), state.Output...)
-	output = append(output, "order_food: "+complete)
-	state.Output = output
-	state.Done = complete
-	return ag.Command{Update: state}, nil
-}
-
-func TestSubAgentsEquivalentFlow(t *testing.T) {
-	planner := &mockLLM{
-		responses: [][]decision{
-			{
-				{Type: "sub_agent", SubAgent: "research lunch options"},
-				{Type: "tool", Tool: "slack_tool"},
-			},
-			{},
-			{},
-			{{Type: "sub_agent", SubAgent: "find vegetarian fallback"}},
-			{{Type: "end", Complete: "order submitted"}},
-		},
-	}
-	workflow := &lunchWorkflow{
-		planner: planner,
-	}
-
-	graph := ag.NewAdvancedStateGraph[lunchState]()
-	graph.AddAsyncChannel("tool_completion_channel")
-	graph.AddAsyncChannel("subagent_completion_channel")
-	graph.AddAsyncChannel("user_input_channel")
-
-	graph.AddEntryNode(workflow.llmNode)
-	graph.AddNode(workflow.waitNode)
-	graph.AddNode(workflow.toolNode)
-	graph.AddNode(workflow.subAgentNode)
-	graph.AddFinishNode(workflow.orderFoodNode)
-
-	handler, err := graph.Compile().Start(
-		nil,
-		lunchState{
-			Input:  "help me get something for lunch",
-			Output: []string{},
-			Done:   "",
-		},
-	)
-	if err != nil {
-		t.Fatalf("start failed: %v", err)
-	}
-
-	time.Sleep(10 * time.Millisecond)
-	if err := handler.PublishToChannel("user_input_channel", "No spicy food please"); err != nil {
-		t.Fatalf("publish failed: %v", err)
-	}
-
-	result, err := handler.WaitForResult()
-	if err != nil {
-		t.Fatalf("result failed: %v", err)
-	}
-
-	output := result.Output
-	if len(output) == 0 {
-		t.Fatalf("output is empty, full result=%#v", result)
-	}
-	if result.Done != "order submitted" {
-		t.Fatalf("unexpected done: %v", result.Done)
-	}
-	if !slices.Contains(output, "user_input: No spicy food please") {
-		t.Fatalf("missing user input output: %#v", output)
-	}
-	if !slices.Contains(output, "tool: tool completed for: slack_tool") {
-		t.Fatalf("missing tool output: %#v", output)
-	}
-	if !slices.Contains(output, "sub_agent: research sub agent completed for: research lunch options") {
-		t.Fatalf("missing first sub-agent output: %#v", output)
-	}
-	if !slices.Contains(output, "sub_agent: research sub agent completed for: find vegetarian fallback") {
-		t.Fatalf("missing second sub-agent output: %#v", output)
-	}
-	timerCount := 0
-	for _, line := range output {
-		if line == "timer: no updates yet" {
-			timerCount++
-		}
-	}
-	if timerCount < 3 {
-		t.Fatalf("expected >=3 timer outputs, got %d, output=%#v", timerCount, output)
-	}
-	if output[len(output)-1] != "order_food: order submitted" {
-		t.Fatalf("unexpected last output: %#v", output[len(output)-1])
-	}
-}

langgraph-go/tests/test_primitives_test.go

@@ -1,589 +0,0 @@
-package tests
-
-import (
-	"fmt"
-	"sync"
-	"testing"
-	"time"
-
-	ag "github.com/langchain-ai/langgraph/langgraph-go/advancedgraph"
-)
-
-type primitiveWorkflow struct {
-	dbWriteCount int
-	intervalMu   sync.Mutex
-	intervals    map[string][2]time.Time
-}
-
-type primitiveState struct {
-	Count int      `json:"count"`
-	Logs  []string `json:"logs"`
-	Done  string   `json:"done"`
-}
-
-func (w *primitiveWorkflow) startNode(ctx *ag.Context, input int, state primitiveState) (ag.Command, error) {
-	state.Logs = append(state.Logs, fmt.Sprintf("start:%d", input))
-	return ag.Command{
-		Update: state,
-		Goto: []ag.Send{
-			{Node: w.middleNode, NodeInput: "from_start"},
-		},
-	}, nil
-}
-
-func (w *primitiveWorkflow) middleNode(ctx *ag.Context, input string, state primitiveState) (ag.Command, error) {
-	state.Logs = append(state.Logs, "middle:"+input)
-	return ag.Command{
-		Update: state,
-		Goto: []ag.Send{
-			{Node: w.finishNode, NodeInput: "from_middle"},
-		},
-	}, nil
-}
-
-func (w *primitiveWorkflow) finishNode(ctx *ag.Context, input string, state primitiveState) (ag.Command, error) {
-	state.Logs = append(state.Logs, "finish:"+input)
-	state.Done = input
-	return ag.Command{Update: state}, nil
-}
-
-func TestInputAndStatePrimitivesCompatible(t *testing.T) {
-	workflow := &primitiveWorkflow{}
-	graph := ag.NewAdvancedStateGraph[primitiveState]()
-
-	graph.AddEntryNode(workflow.startNode)
-	graph.AddNode(workflow.middleNode)
-	graph.AddFinishNode(workflow.finishNode)
-
-	handler, err := graph.Compile().Start(100, primitiveState{
-		Count: 1,
-		Logs:  []string{},
-		Done:  "",
-	})
-	if err != nil {
-		t.Fatalf("start failed: %v", err)
-	}
-
-	result, err := handler.WaitForResult()
-	if err != nil {
-		t.Fatalf("result failed: %v", err)
-	}
-	if result.Done != "from_middle" {
-		t.Fatalf("unexpected done: %v", result.Done)
-	}
-	if result.Count != 1 {
-		t.Fatalf("unexpected count: %v", result.Count)
-	}
-	if len(result.Logs) != 3 || result.Logs[0] != "start:100" || result.Logs[1] != "middle:from_start" || result.Logs[2] != "finish:from_middle" {
-		t.Fatalf("unexpected logs: %#v", result.Logs)
-	}
-}
-
-func (w *primitiveWorkflow) startNoFinishNode(ctx *ag.Context, _ any, state primitiveState) (ag.Command, error) {
-	state.Logs = append(state.Logs, "start")
-	return ag.Command{
-		Update: state,
-		Goto: []ag.Send{
-			{Node: w.middleNoFinishNode, NodeInput: "from_start"},
-		},
-	}, nil
-}
-
-func (w *primitiveWorkflow) middleNoFinishNode(ctx *ag.Context, input string, state primitiveState) (ag.Command, error) {
-	state.Logs = append(state.Logs, "middle:"+input)
-	state.Count += 1
-	state.Done = "stopped"
-	// No goto and no finish node configured: run should end automatically.
-	return ag.Command{Update: state}, nil
-}
-
-func TestRunEndsWithoutFinishNode(t *testing.T) {
-	workflow := &primitiveWorkflow{}
-	graph := ag.NewAdvancedStateGraph[primitiveState]()
-
-	graph.AddEntryNode(workflow.startNoFinishNode)
-	graph.AddNode(workflow.middleNoFinishNode)
-
-	handler, err := graph.Compile().Start(nil, primitiveState{
-		Count: 7,
-		Logs:  []string{},
-		Done:  "",
-	})
-	if err != nil {
-		t.Fatalf("start failed: %v", err)
-	}
-
-	result, err := handler.WaitForResult()
-	if err != nil {
-		t.Fatalf("result failed: %v", err)
-	}
-	if result.Done != "stopped" {
-		t.Fatalf("unexpected done: %v", result.Done)
-	}
-	if result.Count != 8 {
-		t.Fatalf("unexpected count: %v", result.Count)
-	}
-	if len(result.Logs) != 2 || result.Logs[0] != "start" || result.Logs[1] != "middle:from_start" {
-		t.Fatalf("unexpected logs: %#v", result.Logs)
-	}
-}
-
-func (w *primitiveWorkflow) startWaitBatchNode(ctx *ag.Context, _ any, state primitiveState) (ag.Command, error) {
-	if err := ctx.PublishToChannel("events", "a"); err != nil {
-		return ag.Command{}, err
-	}
-	if err := ctx.PublishToChannel("events", "b"); err != nil {
-		return ag.Command{}, err
-	}
-	if err := ctx.PublishToChannel("events", "c"); err != nil {
-		return ag.Command{}, err
-	}
-	return ag.Command{
-		Update: state,
-		Goto: []ag.Send{
-			{Node: w.waitBatchNode, NodeInput: nil},
-		},
-	}, nil
-}
-
-func (w *primitiveWorkflow) waitBatchNode(ctx *ag.Context, _ any, state primitiveState) (ag.Command, error) {
-	result, err := ctx.WaitFor(ag.AnyOf(ag.ChannelCondition{
-		Channel: "events",
-		Min:     2,
-		Max:     4,
-	}))
-	if err != nil {
-		return ag.Command{}, err
-	}
-	if len(result.Conditions) != 1 || !result.Conditions[0].Met {
-		return ag.Command{}, fmt.Errorf("expected one met condition")
-	}
-	values := make([]string, 0, len(result.Conditions[0].Values))
-	for _, v := range result.Conditions[0].Values {
-		s, _ := v.(string)
-		values = append(values, s)
-	}
-	state.Count = len(values)
-	state.Logs = values
-	state.Done = "ok"
-	return ag.Command{Update: state}, nil
-}
-
-func TestChannelWaitRespectsMaxM(t *testing.T) {
-	workflow := &primitiveWorkflow{}
-	graph := ag.NewAdvancedStateGraph[primitiveState]()
-	graph.AddAsyncChannel("events")
-	graph.AddEntryNode(workflow.startWaitBatchNode)
-	graph.AddFinishNode(workflow.waitBatchNode)
-
-	handler, err := graph.Compile().Start(nil, primitiveState{
-		Count: 0,
-		Logs:  []string{},
-		Done:  "",
-	})
-	if err != nil {
-		t.Fatalf("start failed: %v", err)
-	}
-
-	result, err := handler.WaitForResult()
-	if err != nil {
-		t.Fatalf("result failed: %v", err)
-	}
-	if result.Count != 3 {
-		t.Fatalf("unexpected count: %v", result.Count)
-	}
-	if len(result.Logs) != 3 || result.Logs[0] != "a" || result.Logs[1] != "b" || result.Logs[2] != "c" {
-		t.Fatalf("unexpected logs: %#v", result.Logs)
-	}
-	if result.Done != "ok" {
-		t.Fatalf("unexpected done: %v", result.Done)
-	}
-}
-
-func (w *primitiveWorkflow) startAnyOfTwoChannelsNode(ctx *ag.Context, _ any, state primitiveState) (ag.Command, error) {
-	if err := ctx.PublishToChannel("alpha", "a1"); err != nil {
-		return ag.Command{}, err
-	}
-	if err := ctx.PublishToChannel("beta", "b1"); err != nil {
-		return ag.Command{}, err
-	}
-	return ag.Command{
-		Update: state,
-		Goto: []ag.Send{
-			{Node: w.waitAnyOfTwoChannelsNode, NodeInput: nil},
-		},
-	}, nil
-}
-
-func (w *primitiveWorkflow) waitAnyOfTwoChannelsNode(ctx *ag.Context, _ any, state primitiveState) (ag.Command, error) {
-	first, err := ctx.WaitFor(ag.AnyOf(
-		ag.ChannelCondition{Channel: "alpha"},
-		ag.ChannelCondition{Channel: "beta"},
-	))
-	if err != nil {
-		return ag.Command{}, err
-	}
-	if len(first.Conditions) != 2 {
-		return ag.Command{}, fmt.Errorf("expected 2 condition results, got %d", len(first.Conditions))
-	}
-	if !first.Conditions[0].Met || first.Conditions[0].ChannelName != "alpha" || len(first.Conditions[0].Values) != 1 || first.Conditions[0].Values[0] != "a1" {
-		return ag.Command{}, fmt.Errorf("unexpected first condition result: %#v", first.Conditions[0])
-	}
-	if !first.Conditions[1].Met || first.Conditions[1].ChannelName != "beta" || len(first.Conditions[1].Values) != 1 || first.Conditions[1].Values[0] != "b1" {
-		return ag.Command{}, fmt.Errorf("unexpected second condition result: %#v", first.Conditions[1])
-	}
-	if err := ctx.PublishToChannel("beta", "b2"); err != nil {
-		return ag.Command{}, err
-	}
-	state.Count = 1
-	state.Logs = []string{
-		"matched=2",
-	}
-	return ag.Command{
-		Update: state,
-		Goto: []ag.Send{
-			{Node: w.verifyBetaAfterAnyOfNode, NodeInput: nil},
-		},
-	}, nil
-}
-
-func (w *primitiveWorkflow) verifyBetaAfterAnyOfNode(ctx *ag.Context, _ any, state primitiveState) (ag.Command, error) {
-	second, err := ctx.WaitFor(ag.AnyOf(
-		ag.ChannelCondition{Channel: "beta"},
-	))
-	if err != nil {
-		return ag.Command{}, err
-	}
-	if len(second.Conditions) != 1 || !second.Conditions[0].Met || second.Conditions[0].ChannelName != "beta" || len(second.Conditions[0].Values) != 1 {
-		return ag.Command{}, fmt.Errorf("unexpected beta condition result: %#v", second.Conditions)
-	}
-	payload, _ := second.Conditions[0].Values[0].(string)
-	state.Count = 2
-	state.Logs = append(state.Logs, fmt.Sprintf("beta=%s", payload))
-	state.Done = "ok"
-	return ag.Command{Update: state}, nil
-}
-
-func TestAnyOfConsumesAllReadyChannels(t *testing.T) {
-	workflow := &primitiveWorkflow{}
-	graph := ag.NewAdvancedStateGraph[primitiveState]()
-	graph.AddAsyncChannel("alpha")
-	graph.AddAsyncChannel("beta")
-	graph.AddEntryNode(workflow.startAnyOfTwoChannelsNode)
-	graph.AddNode(workflow.waitAnyOfTwoChannelsNode)
-	graph.AddFinishNode(workflow.verifyBetaAfterAnyOfNode)
-
-	handler, err := graph.Compile().Start(nil, primitiveState{
-		Count: 0,
-		Logs:  []string{},
-		Done:  "",
-	})
-	if err != nil {
-		t.Fatalf("start failed: %v", err)
-	}
-
-	result, err := handler.WaitForResult()
-	if err != nil {
-		t.Fatalf("result failed: %v", err)
-	}
-	if result.Count != 2 {
-		t.Fatalf("unexpected count: %v", result.Count)
-	}
-	if len(result.Logs) != 2 || result.Logs[0] != "matched=2" || result.Logs[1] != "beta=b2" {
-		t.Fatalf("unexpected logs: %#v", result.Logs)
-	}
-	if result.Done != "ok" {
-		t.Fatalf("unexpected done: %v", result.Done)
-	}
-}
-
-func (w *primitiveWorkflow) startAllOfTwoChannelsNode(ctx *ag.Context, _ any, state primitiveState) (ag.Command, error) {
-	if err := ctx.PublishToChannel("alpha", "a1"); err != nil {
-		return ag.Command{}, err
-	}
-	return ag.Command{
-		Update: state,
-		Goto: []ag.Send{
-			{Node: w.waitAllOfTwoChannelsNode, NodeInput: nil},
-		},
-	}, nil
-}
-
-func (w *primitiveWorkflow) waitAllOfTwoChannelsNode(ctx *ag.Context, _ any, state primitiveState) (ag.Command, error) {
-	result, err := ctx.WaitFor(ag.AllOf(
-		ag.ChannelCondition{Channel: "alpha"},
-		ag.ChannelCondition{Channel: "beta"},
-	))
-	if err != nil {
-		return ag.Command{}, err
-	}
-	if len(result.Conditions) != 2 {
-		return ag.Command{}, fmt.Errorf("expected 2 condition results, got %d", len(result.Conditions))
-	}
-	if !result.Conditions[0].Met || result.Conditions[0].ChannelName != "alpha" || len(result.Conditions[0].Values) != 1 || result.Conditions[0].Values[0] != "a1" {
-		return ag.Command{}, fmt.Errorf("unexpected alpha condition result: %#v", result.Conditions[0])
-	}
-	if !result.Conditions[1].Met || result.Conditions[1].ChannelName != "beta" || len(result.Conditions[1].Values) != 1 || result.Conditions[1].Values[0] != "b1" {
-		return ag.Command{}, fmt.Errorf("unexpected beta condition result: %#v", result.Conditions[1])
-	}
-	state.Count = 2
-	state.Logs = []string{"all_of_channels_ok"}
-	state.Done = "ok"
-	return ag.Command{Update: state}, nil
-}
-
-func TestAllOfWaitsUntilAllChannelsAreReady(t *testing.T) {
-	workflow := &primitiveWorkflow{}
-	graph := ag.NewAdvancedStateGraph[primitiveState]()
-	graph.AddAsyncChannel("alpha")
-	graph.AddAsyncChannel("beta")
-	graph.AddEntryNode(workflow.startAllOfTwoChannelsNode)
-	graph.AddFinishNode(workflow.waitAllOfTwoChannelsNode)
-
-	handler, err := graph.Compile().Start(nil, primitiveState{
-		Count: 0,
-		Logs:  []string{},
-		Done:  "",
-	})
-	if err != nil {
-		t.Fatalf("start failed: %v", err)
-	}
-	if err := handler.PublishToChannel("beta", "b1"); err != nil {
-		t.Fatalf("publish beta failed: %v", err)
-	}
-
-	result, err := handler.WaitForResult()
-	if err != nil {
-		t.Fatalf("result failed: %v", err)
-	}
-	if result.Count != 2 {
-		t.Fatalf("unexpected count: %v", result.Count)
-	}
-	if len(result.Logs) != 1 || result.Logs[0] != "all_of_channels_ok" {
-		t.Fatalf("unexpected logs: %#v", result.Logs)
-	}
-	if result.Done != "ok" {
-		t.Fatalf("unexpected done: %v", result.Done)
-	}
-}
-
-func (w *primitiveWorkflow) startAllOfChannelTimerNode(ctx *ag.Context, _ any, state primitiveState) (ag.Command, error) {
-	if err := ctx.PublishToChannel("alpha", "a1"); err != nil {
-		return ag.Command{}, err
-	}
-	return ag.Command{
-		Update: state,
-		Goto: []ag.Send{
-			{Node: w.waitAllOfChannelTimerNode, NodeInput: nil},
-		},
-	}, nil
-}
-
-func (w *primitiveWorkflow) waitAllOfChannelTimerNode(ctx *ag.Context, _ any, state primitiveState) (ag.Command, error) {
-	result, err := ctx.WaitFor(ag.AllOf(
-		ag.ChannelCondition{Channel: "alpha"},
-		ag.TimerCondition{Seconds: 0.05},
-	))
-	if err != nil {
-		return ag.Command{}, err
-	}
-	if len(result.Conditions) != 2 {
-		return ag.Command{}, fmt.Errorf("expected 2 condition results, got %d", len(result.Conditions))
-	}
-	if !result.Conditions[0].Met || result.Conditions[0].ChannelName != "alpha" || len(result.Conditions[0].Values) != 1 || result.Conditions[0].Values[0] != "a1" {
-		return ag.Command{}, fmt.Errorf("unexpected channel condition result: %#v", result.Conditions[0])
-	}
-	if !result.Conditions[1].Met {
-		return ag.Command{}, fmt.Errorf("timer condition should be met: %#v", result.Conditions[1])
-	}
-	state.Count = 1
-	state.Logs = []string{"all_of_channel_timer_ok"}
-	state.Done = "ok"
-	return ag.Command{Update: state}, nil
-}
-
-func TestAllOfChannelAndTimerMarksBothConditions(t *testing.T) {
-	workflow := &primitiveWorkflow{}
-	graph := ag.NewAdvancedStateGraph[primitiveState]()
-	graph.AddAsyncChannel("alpha")
-	graph.AddEntryNode(workflow.startAllOfChannelTimerNode)
-	graph.AddFinishNode(workflow.waitAllOfChannelTimerNode)
-
-	handler, err := graph.Compile().Start(nil, primitiveState{
-		Count: 0,
-		Logs:  []string{},
-		Done:  "",
-	})
-	if err != nil {
-		t.Fatalf("start failed: %v", err)
-	}
-
-	result, err := handler.WaitForResult()
-	if err != nil {
-		t.Fatalf("result failed: %v", err)
-	}
-	if result.Count != 1 {
-		t.Fatalf("unexpected count: %v", result.Count)
-	}
-	if len(result.Logs) != 1 || result.Logs[0] != "all_of_channel_timer_ok" {
-		t.Fatalf("unexpected logs: %#v", result.Logs)
-	}
-	if result.Done != "ok" {
-		t.Fatalf("unexpected done: %v", result.Done)
-	}
-}
-
-func (w *primitiveWorkflow) startResumeFlagNode(ctx *ag.Context, _ any, state primitiveState) (ag.Command, error) {
-	state.Logs = []string{}
-	state.Count = 0
-	return ag.Command{
-		Update: state,
-		Goto: []ag.Send{
-			{Node: w.resumeFlagNode, NodeInput: nil},
-		},
-	}, nil
-}
-
-func (w *primitiveWorkflow) resumeFlagNode(ctx *ag.Context, _ any, state primitiveState) (ag.Command, error) {
-	if !ctx.IsResume() {
-		// Simulate one-time side effect (e.g. DB write).
-		w.dbWriteCount += 1
-	}
-	if _, err := ctx.WaitFor(ag.AnyOf(ag.TimerCondition{Seconds: 0.02})); err != nil {
-		return ag.Command{}, err
-	}
-	state.Logs = append(state.Logs, fmt.Sprintf("resume=%v", ctx.IsResume()))
-	return ag.Command{
-		Update: state,
-		Goto: []ag.Send{
-			{Node: w.finishResumeFlagNode, NodeInput: nil},
-		},
-	}, nil
-}
-
-func (w *primitiveWorkflow) finishResumeFlagNode(_ *ag.Context, _ any, state primitiveState) (ag.Command, error) {
-	state.Done = "ok"
-	return ag.Command{Update: state}, nil
-}
-
-func TestIsResumeAvoidsDuplicateSideEffects(t *testing.T) {
-	workflow := &primitiveWorkflow{}
-	graph := ag.NewAdvancedStateGraph[primitiveState]()
-	graph.AddEntryNode(workflow.startResumeFlagNode)
-	graph.AddNode(workflow.resumeFlagNode)
-	graph.AddFinishNode(workflow.finishResumeFlagNode)
-
-	handler, err := graph.Compile().Start(nil, primitiveState{
-		Count: 0,
-		Logs:  []string{},
-		Done:  "",
-	})
-	if err != nil {
-		t.Fatalf("start failed: %v", err)
-	}
-
-	result, err := handler.WaitForResult()
-	if err != nil {
-		t.Fatalf("result failed: %v", err)
-	}
-	if workflow.dbWriteCount != 1 {
-		t.Fatalf("db write should happen once, got=%v", workflow.dbWriteCount)
-	}
-	if len(result.Logs) != 1 || result.Logs[0] != "resume=true" {
-		t.Fatalf("unexpected logs: %#v", result.Logs)
-	}
-	if result.Done != "ok" {
-		t.Fatalf("unexpected done: %v", result.Done)
-	}
-}
-
-func (w *primitiveWorkflow) startLockedWorkersNode(_ *ag.Context, _ any, state primitiveState) (ag.Command, error) {
-	w.intervalMu.Lock()
-	w.intervals = map[string][2]time.Time{}
-	w.intervalMu.Unlock()
-	return ag.Command{
-		Update: state,
-		Goto: []ag.Send{
-			{Node: w.lockedWorkerANode, NodeInput: nil},
-			{Node: w.lockedWorkerBNode, NodeInput: nil},
-			{Node: w.waitLockedWorkersNode, NodeInput: nil},
-		},
-	}, nil
-}
-
-func (w *primitiveWorkflow) lockedWorkerANode(ctx *ag.Context, _ any, state primitiveState) (ag.Command, error) {
-	start := time.Now()
-	time.Sleep(40 * time.Millisecond)
-	end := time.Now()
-	w.intervalMu.Lock()
-	w.intervals["a"] = [2]time.Time{start, end}
-	w.intervalMu.Unlock()
-	if err := ctx.PublishToChannel("done", "a"); err != nil {
-		return ag.Command{}, err
-	}
-	return ag.Command{Update: state}, nil
-}
-
-func (w *primitiveWorkflow) lockedWorkerBNode(ctx *ag.Context, _ any, state primitiveState) (ag.Command, error) {
-	start := time.Now()
-	time.Sleep(40 * time.Millisecond)
-	end := time.Now()
-	w.intervalMu.Lock()
-	w.intervals["b"] = [2]time.Time{start, end}
-	w.intervalMu.Unlock()
-	if err := ctx.PublishToChannel("done", "b"); err != nil {
-		return ag.Command{}, err
-	}
-	return ag.Command{Update: state}, nil
-}
-
-func (w *primitiveWorkflow) waitLockedWorkersNode(ctx *ag.Context, _ any, state primitiveState) (ag.Command, error) {
-	if _, err := ctx.WaitFor(ag.AnyOf(ag.ChannelCondition{Channel: "done", Min: 2})); err != nil {
-		return ag.Command{}, err
-	}
-	return ag.Command{
-		Update: state,
-		Goto:   []ag.Send{{Node: w.finishResumeFlagNode, NodeInput: nil}},
-	}, nil
-}
-
-func TestStateFieldLockingSerializesConflictingNodes(t *testing.T) {
-	workflow := &primitiveWorkflow{}
-	graph := ag.NewAdvancedStateGraph[primitiveState]()
-	graph.AddAsyncChannel("done")
-	graph.AddEntryNode(workflow.startLockedWorkersNode)
-	graph.AddNode(
-		workflow.lockedWorkerANode,
-		ag.NodeStateOption{LockedFields: []string{"counter"}},
-	)
-	graph.AddNode(
-		workflow.lockedWorkerBNode,
-		ag.NodeStateOption{LockedFields: []string{"counter"}},
-	)
-	graph.AddNode(workflow.waitLockedWorkersNode)
-	graph.AddFinishNode(workflow.finishResumeFlagNode)
-
-	handler, err := graph.Compile().Start(nil, primitiveState{
-		Count: 0,
-		Logs:  []string{},
-		Done:  "",
-	})
-	if err != nil {
-		t.Fatalf("start failed: %v", err)
-	}
-	if _, err := handler.WaitForResult(); err != nil {
-		t.Fatalf("result failed: %v", err)
-	}
-
-	workflow.intervalMu.Lock()
-	ia, okA := workflow.intervals["a"]
-	ib, okB := workflow.intervals["b"]
-	workflow.intervalMu.Unlock()
-	if !okA || !okB {
-		t.Fatalf("missing worker intervals: %#v", workflow.intervals)
-	}
-	serialized := !ia[1].After(ib[0]) || !ib[1].After(ia[0])
-	if !serialized {
-		t.Fatalf("expected serialized execution, got overlap: a=%v..%v b=%v..%v", ia[0], ia[1], ib[0], ib[1])
-	}
-}

langgraph-go/tests/test_state_type_validation_test.go

@@ -1,54 +0,0 @@
-package tests
-
-import (
-	"strings"
-	"testing"
-
-	ag "github.com/langchain-ai/langgraph/langgraph-go/advancedgraph"
-)
-
-func TestNewAdvancedStateGraphRejectsNonStructState(t *testing.T) {
-	defer func() {
-		if r := recover(); r == nil {
-			t.Fatalf("expected panic for non-struct StateT")
-		}
-	}()
-	_ = ag.NewAdvancedStateGraph[map[string]any]()
-}
-
-type stateTypeA struct {
-	X int `json:"x"`
-}
-
-type stateTypeB struct {
-	X int `json:"x"`
-}
-
-type wrongUpdateWorkflow struct{}
-
-func (w *wrongUpdateWorkflow) startNode(ctx *ag.Context, _ any, _ stateTypeA) (ag.Command, error) {
-	return ag.Command{Goto: []ag.Send{{Node: w.badNode}}}, nil
-}
-
-func (w *wrongUpdateWorkflow) badNode(ctx *ag.Context, _ any, _ stateTypeA) (ag.Command, error) {
-	return ag.Command{Update: stateTypeB{X: 1}}, nil
-}
-
-func TestNodeUpdateTypeMustMatchGraphStateType(t *testing.T) {
-	workflow := &wrongUpdateWorkflow{}
-	graph := ag.NewAdvancedStateGraph[stateTypeA]()
-	graph.AddEntryNode(workflow.startNode)
-	graph.AddFinishNode(workflow.badNode)
-
-	handler, err := graph.Compile().Start(nil, stateTypeA{X: 0})
-	if err != nil {
-		t.Fatalf("start failed: %v", err)
-	}
-	_, err = handler.WaitForResult()
-	if err == nil {
-		t.Fatalf("expected runtime error for wrong update type")
-	}
-	if !strings.Contains(err.Error(), "update type mismatch") {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}

langgraph-go/tests/test_streaming_test.go

@@ -1,117 +0,0 @@
-package tests
-
-import (
-	"strings"
-	"testing"
-	"time"
-
-	ag "github.com/langchain-ai/langgraph/langgraph-go/advancedgraph"
-)
-
-type streamState struct {
-	Done bool `json:"done"`
-}
-
-type streamWorkflow struct{}
-
-func (w *streamWorkflow) startNode(ctx *ag.Context, _ any, state streamState) (ag.Command, error) {
-	if err := ctx.SendCustomStreamEvent("high", map[string]any{"step": "start", "value": 1}); err != nil {
-		return ag.Command{}, err
-	}
-	time.Sleep(80 * time.Millisecond)
-	if err := ctx.SendCustomStreamEvent("regular", map[string]any{"step": "start", "value": 2}); err != nil {
-		return ag.Command{}, err
-	}
-	return ag.Command{
-		Update: state,
-		Goto: []ag.Send{
-			{Node: w.finishNode},
-		},
-	}, nil
-}
-
-func (w *streamWorkflow) finishNode(ctx *ag.Context, _ any, state streamState) (ag.Command, error) {
-	state.Done = true
-	return ag.Command{Update: state}, nil
-}
-
-func TestCustomStreamReceiveAndClose(t *testing.T) {
-	workflow := &streamWorkflow{}
-	graph := ag.NewAdvancedStateGraph[streamState]()
-	graph.AddCustomOutputStream("high")
-	graph.AddCustomOutputStream("regular")
-	graph.AddEntryNode(workflow.startNode)
-	graph.AddFinishNode(workflow.finishNode)
-
-	handler, err := graph.Compile().Start(nil, streamState{Done: false}, "custom")
-	if err != nil {
-		t.Fatalf("start failed: %v", err)
-	}
-
-	event, err := handler.ReceiveStream("high")
-	if err != nil {
-		t.Fatalf("receive stream failed: %v", err)
-	}
-	if event == nil {
-		t.Fatalf("expected first stream event, got nil")
-	}
-	eventMap, ok := event.(map[string]any)
-	if !ok {
-		t.Fatalf("unexpected event type: %T", event)
-	}
-	if eventMap["step"] != "start" {
-		t.Fatalf("unexpected stream event payload: %#v", eventMap)
-	}
-
-	eventRegular, err := handler.ReceiveStream("regular")
-	if err != nil {
-		t.Fatalf("receive regular stream failed: %v", err)
-	}
-	eventRegularMap, ok := eventRegular.(map[string]any)
-	if !ok {
-		t.Fatalf("unexpected regular event type: %T", eventRegular)
-	}
-	if eventRegularMap["value"] != float64(2) {
-		t.Fatalf("unexpected regular stream payload: %#v", eventRegularMap)
-	}
-
-	if err := handler.CloseAllStreams(); err != nil {
-		t.Fatalf("close all streams failed: %v", err)
-	}
-
-	closedEvent, err := handler.ReceiveStream("high")
-	if err != nil {
-		t.Fatalf("receive stream after close failed: %v", err)
-	}
-	if closedEvent != nil {
-		t.Fatalf("expected nil stream event after close, got %#v", closedEvent)
-	}
-
-	result, err := handler.WaitForResult()
-	if err != nil {
-		t.Fatalf("result failed: %v", err)
-	}
-	if !result.Done {
-		t.Fatalf("expected final state done=true, got %#v", result)
-	}
-}
-
-func TestOnlyCustomStreamModeSupported(t *testing.T) {
-	workflow := &streamWorkflow{}
-	graph := ag.NewAdvancedStateGraph[streamState]()
-	graph.AddCustomOutputStream("regular")
-	graph.AddEntryNode(workflow.startNode)
-	graph.AddFinishNode(workflow.finishNode)
-
-	handler, err := graph.Compile().Start(nil, streamState{Done: false}, "values")
-	if err != nil {
-		t.Fatalf("start failed: %v", err)
-	}
-	_, runErr := handler.WaitForResult()
-	if runErr == nil {
-		t.Fatalf("expected run error for unsupported stream mode")
-	}
-	if !strings.Contains(runErr.Error(), "only `custom` is supported") {
-		t.Fatalf("unexpected error: %v", runErr)
-	}
-}

langgraph-go/tests/test_update_elision_test.go

@@ -1,135 +0,0 @@
-package tests
-
-import (
-	"reflect"
-	"testing"
-	"time"
-
-	ag "github.com/langchain-ai/langgraph/langgraph-go/advancedgraph"
-)
-
-type updateElisionState struct {
-	X  int             `json:"x"`
-	S  updateStruct    `json:"s"`
-	M  map[string]int  `json:"m"`
-	L  []int           `json:"l"`
-	PS *updateStruct   `json:"ps"`
-	PM *map[string]int `json:"pm"`
-	PL *[]int          `json:"pl"`
-}
-
-type updateStruct struct {
-	V int `json:"v"`
-}
-
-type updateElisionWorkflow struct{}
-
-func makeState(v int) updateElisionState {
-	m := map[string]int{"n": v}
-	l := []int{v}
-	return updateElisionState{
-		X:  v,
-		S:  updateStruct{V: v},
-		M:  map[string]int{"n": v},
-		L:  []int{v},
-		PS: &updateStruct{V: v},
-		PM: &m,
-		PL: &l,
-	}
-}
-
-func (w *updateElisionWorkflow) startNoopNode(ctx *ag.Context, _ any, _ updateElisionState) (ag.Command, error) {
-	return ag.Command{
-		Goto: []ag.Send{
-			{Node: w.fastNode},
-			{Node: w.slowNoopNode},
-		},
-	}, nil
-}
-
-func (w *updateElisionWorkflow) startChangedNode(ctx *ag.Context, _ any, _ updateElisionState) (ag.Command, error) {
-	return ag.Command{
-		Goto: []ag.Send{
-			{Node: w.fastNode},
-			{Node: w.slowChangedNode},
-		},
-	}, nil
-}
-
-func (w *updateElisionWorkflow) fastNode(ctx *ag.Context, _ any, state updateElisionState) (ag.Command, error) {
-	_ = state
-	return ag.Command{Update: makeState(1)}, nil
-}
-
-func (w *updateElisionWorkflow) slowNoopNode(ctx *ag.Context, _ any, state updateElisionState) (ag.Command, error) {
-	time.Sleep(100 * time.Millisecond)
-	// Returns same state as initial snapshot; without runtime elision this can overwrite newer updates.
-	return ag.Command{Update: state}, nil
-}
-
-func (w *updateElisionWorkflow) slowChangedNode(ctx *ag.Context, _ any, _ updateElisionState) (ag.Command, error) {
-	time.Sleep(100 * time.Millisecond)
-	// Real change should not be elided.
-	return ag.Command{Update: makeState(2)}, nil
-}
-
-func assertStateEquals(t *testing.T, got updateElisionState, expected updateElisionState) {
-	t.Helper()
-	if got.X != expected.X {
-		t.Fatalf("unexpected X: got=%d want=%d", got.X, expected.X)
-	}
-	if got.S != expected.S {
-		t.Fatalf("unexpected S: got=%#v want=%#v", got.S, expected.S)
-	}
-	if !reflect.DeepEqual(got.M, expected.M) {
-		t.Fatalf("unexpected M: got=%#v want=%#v", got.M, expected.M)
-	}
-	if !reflect.DeepEqual(got.L, expected.L) {
-		t.Fatalf("unexpected L: got=%#v want=%#v", got.L, expected.L)
-	}
-	if got.PS == nil || expected.PS == nil || *got.PS != *expected.PS {
-		t.Fatalf("unexpected PS: got=%#v want=%#v", got.PS, expected.PS)
-	}
-	if got.PM == nil || expected.PM == nil || !reflect.DeepEqual(*got.PM, *expected.PM) {
-		t.Fatalf("unexpected PM: got=%#v want=%#v", got.PM, expected.PM)
-	}
-	if got.PL == nil || expected.PL == nil || !reflect.DeepEqual(*got.PL, *expected.PL) {
-		t.Fatalf("unexpected PL: got=%#v want=%#v", got.PL, expected.PL)
-	}
-}
-
-func TestNoopSlowUpdateCanOverrideFastUpdate(t *testing.T) {
-	workflow := &updateElisionWorkflow{}
-	graph := ag.NewAdvancedStateGraph[updateElisionState]()
-	graph.AddEntryNode(workflow.startNoopNode)
-	graph.AddNode(workflow.fastNode)
-	graph.AddFinishNode(workflow.slowNoopNode)
-
-	handler, err := graph.Compile().Start(nil, makeState(0))
-	if err != nil {
-		t.Fatalf("start failed: %v", err)
-	}
-	result, err := handler.WaitForResult()
-	if err != nil {
-		t.Fatalf("result failed: %v", err)
-	}
-	assertStateEquals(t, result, makeState(0))
-}
-
-func TestChangedSlowUpdateOverridesFastUpdate(t *testing.T) {
-	workflow := &updateElisionWorkflow{}
-	graph := ag.NewAdvancedStateGraph[updateElisionState]()
-	graph.AddEntryNode(workflow.startChangedNode)
-	graph.AddNode(workflow.fastNode)
-	graph.AddFinishNode(workflow.slowChangedNode)
-
-	handler, err := graph.Compile().Start(nil, makeState(0))
-	if err != nil {
-		t.Fatalf("start failed: %v", err)
-	}
-	result, err := handler.WaitForResult()
-	if err != nil {
-		t.Fatalf("result failed: %v", err)
-	}
-	assertStateEquals(t, result, makeState(2))
-}

langgraph-java/.gitignore

@@ -0,0 +1,90 @@
+##############################
+## Java
+##############################
+.mtj.tmp/
+*.class
+*.jar
+*.war
+*.ear
+*.nar
+hs_err_pid*
+replay_pid*
+
+##############################
+## Maven
+##############################
+target/
+pom.xml.tag
+pom.xml.releaseBackup
+pom.xml.versionsBackup
+pom.xml.next
+pom.xml.bak
+release.properties
+dependency-reduced-pom.xml
+buildNumber.properties
+.mvn/timing.properties
+.mvn/wrapper/maven-wrapper.jar
+
+##############################
+## Gradle
+##############################
+bin/
+build/
+.gradle
+.gradletasknamecache
+gradle-app.setting
+!gradle-wrapper.jar
+
+##############################
+## IntelliJ
+##############################
+out/
+.idea/
+.idea_modules/
+*.iml
+*.ipr
+*.iws
+
+##############################
+## Eclipse
+##############################
+.settings/
+bin/
+tmp/
+.metadata
+.classpath
+.project
+*.tmp
+*.bak
+*.swp
+*~.nib
+local.properties
+.loadpath
+.factorypath
+
+##############################
+## NetBeans
+##############################
+nbproject/private/
+build/
+nbbuild/
+dist/
+nbdist/
+nbactions.xml
+nb-configuration.xml
+
+##############################
+## Visual Studio Code
+##############################
+.vscode/
+.code-workspace
+
+##############################
+## OS X
+##############################
+.DS_Store
+
+##############################
+## Miscellaneous
+##############################
+*.log

langgraph-java/CHANNEL_INITIALIZATION.md

@@ -0,0 +1,107 @@
+# Channel Initialization in Java LangGraph
+
+This document explains how channel initialization is handled in the Java implementation of LangGraph, matching Python's behavior.
+
+## Current Implementation 
+
+### Java Implementation (Python-Compatible)
+
+In the Java implementation:
+
+1. **First Superstep Behavior**:
+   - Only nodes that have the input channel as one of their triggers run in the first superstep
+   - This matches Python's behavior for graph execution
+
+2. **Channel Reading**:
+   - Channels that haven't been initialized return `null` values (instead of throwing exceptions)
+   - Nodes are expected to handle potentially `null` values from uninitialized channels
+
+3. **Graph Execution**:
+   - Subsequent supersteps only execute nodes that:
+     - Subscribe to a channel that was updated
+     - OR have a trigger matching a channel that was updated
+
+## Key Distinctions
+
+There's an important distinction between:
+
+1. **Input channels** - Channels from which the node reads values when it executes
+2. **Trigger channels** - Channels that determine when this node should execute
+
+In our Java implementation:
+- `channels` property defines which channels the node reads from
+- `triggerChannels` property defines which channels can cause the node to execute
+
+This naming is more intuitive and aligns better with the conceptual distinction between reading from a channel and being triggered by a channel.
+
+## Implementation Details
+
+The Python-compatible implementation in Java LangGraph makes the following changes:
+
+1. Modified `TaskPlanner.plan()` to only execute nodes with input channel triggers in the first superstep
+2. Updated tests to:
+   - Add triggers for nodes that should execute on first superstep (e.g., `trigger("input")`)
+   - Remove unnecessary manual channel initialization that was previously used to avoid EmptyChannelException
+   - Use input maps to provide initial values instead of `channel.update()`
+   - Only keep manual initialization in specific test cases that need it (like the mix of initialized/uninitialized channels test)
+3. Clarified the distinction between "subscribe to read" and "trigger to execute" semantics
+
+## Recommended Practices
+
+When building graphs with the Java implementation, follow these practices to ensure Python compatibility:
+
+### 1. Add trigger channels to nodes
+
+Always add appropriate trigger channels to nodes that should execute in the first superstep:
+
+```java
+PregelNode node = new PregelNode.Builder("node", executable)
+    .channel("input")          // Channel to read from
+    .triggerChannel("input")   // Channel that triggers execution 
+    .writer("output")
+    .build();
+```
+
+You can also add multiple trigger channels if needed:
+
+```java
+PregelNode node = new PregelNode.Builder("node", executable)
+    .channel("input1")
+    .channel("input2")
+    .triggerChannel("input1")   // Will trigger on this channel
+    .triggerChannel("input2")   // And also on this channel
+    .writer("output")
+    .build();
+```
+
+### 2. Handle uninitialized channels gracefully
+
+Inside node execution logic, handle potentially uninitialized channels using default values:
+
+```java
+// Handle uninitialized channels with a default value
+Integer input = 0; // Default value for uninitialized channel
+if (inputs.containsKey("inputChannel") && inputs.get("inputChannel") != null) {
+    input = (Integer) inputs.get("inputChannel");
+}
+```
+
+### 3. Provide initial values through input map
+
+Instead of manually initializing channels, provide initial values through the input map:
+
+```java
+// DO NOT do this:
+// channel.update(Collections.singletonList(initialValue));
+
+// Instead, provide values in the input map:
+Map<String, Object> input = new HashMap<>();
+input.put("inputChannel", initialValue);
+Object result = pregel.invoke(input, null);
+```
+
+### 4. Remember execution rules
+
+- Only nodes with input channel as a trigger run in the first superstep
+- In subsequent supersteps, nodes run if they subscribe to or have a trigger matching an updated channel
+- Uninitialized channels return `null` or empty collections rather than throwing exceptions

langgraph-java/PYTHON_JAVA_MAPPING.md

@@ -0,0 +1,88 @@
+# Python-Java Implementation Mapping
+
+This document records the mapping between Python and Java implementations of LangGraph, highlighting any deliberate differences and their rationale.
+
+## Core Components
+
+### Channels
+
+| Component | Python Path | Java Path | Deviations |
+|-----------|-------------|-----------|------------|
+| BaseChannel | langgraph/channels/base.py | com.langgraph.channels.BaseChannel | Java uses interface with default methods instead of Python's abstract base class. Channel returns null or empty values when uninitialized, rather than throwing exceptions. |
+| AbstractChannel | langgraph/channels/base.py | com.langgraph.channels.AbstractChannel | Java implementation provides default functionality shared by channel implementations. Added Python compatibility for uninitialized channels. |
+| TopicChannel | langgraph/channels/topic_channel.py | com.langgraph.channels.TopicChannel | Java implementation preserves Python's multi-value behavior while using Java collections. Returns empty list for uninitialized channels. |
+| LastValue | langgraph/channels/last_value.py | com.langgraph.channels.LastValue | Returns null for uninitialized channels to match Python behavior. |
+| EphemeralValue | langgraph/channels/ephemeral_value.py | com.langgraph.channels.EphemeralValue | Returns null for uninitialized channels to match Python behavior. |
+| Channels (utility) | langgraph/channels/__init__.py | com.langgraph.channels.Channels | Java uses utility class with static methods instead of module-level functions. |
+
+### Pregel Algorithm
+
+| Component | Python Path | Java Path | Deviations |
+|-----------|-------------|-----------|------------|
+| PregelNode | langgraph/pregel/algorithm.py | com.langgraph.pregel.PregelNode | Java exposes these concepts with clearer naming: 'channels' (input channels to read from) and 'triggerChannels' (channels that trigger execution). Java now supports multiple trigger channels like Python. |
+| Pregel | langgraph/pregel/pregel.py | com.langgraph.pregel.Pregel | Java uses Builder pattern instead of Python's initialization parameters. Functionally equivalent. |
+| PregelLoop | langgraph/pregel/pregel_loop.py | com.langgraph.pregel.execute.PregelLoop | Implementation follows Java conventions with robust cycle detection. Ensures runs complete when possible by executing a final validation step before throwing recursion errors. |
+| Runner Functions | langgraph/pregel/runner.py | com.langgraph.pregel.execute.SuperstepManager | Python's functional approach mapped to Java's object-oriented design. |
+| Algorithm Functions | langgraph/pregel/algo.py | Various Java classes | Python's functional approach distributed across several Java classes according to responsibility. |
+| TaskPlanner | langgraph/pregel/algo.py | com.langgraph.pregel.task.TaskPlanner | Java implementation now matches Python: only nodes with the input channel as a trigger execute on first run. See CHANNEL_INITIALIZATION.md for details. |
+
+### Checkpoint
+
+| Component | Python Path | Java Path | Deviations |
+|-----------|-------------|-----------|------------|
+| BaseCheckpointSaver | langgraph/checkpoint/base.py | com.langgraph.checkpoint.base.BaseCheckpointSaver | Java uses interfaces rather than abstract classes where appropriate. |
+| MemoryCheckpointSaver | langgraph/checkpoint/memory.py | com.langgraph.checkpoint.base.memory.MemoryCheckpointSaver | Java implementation uses more type safety but maintains same functionality. |
+| Serializer | langgraph/checkpoint/serde.py | com.langgraph.checkpoint.serde.Serializer | Java uses interface with specific implementations for different serialization approaches. |
+
+## Method-Level Mappings
+
+### PregelLoop (Python: langgraph/pregel/loop.py, Java: com.langgraph.pregel.execute.PregelLoop)
+
+| Python Method | Java Method | Deviations |
+|---------------|-------------|------------|
+| `__init__` | Constructor + Builder pattern | Java uses Builder pattern for more flexible initialization. |
+| `tick` | `execute` | Same core functionality, but with improved recursion detection that matches Python behavior while being more resilient. Java executes a final validation step before throwing recursion errors to ensure runs complete when possible. |
+| `_first` | `initializeWithInput` | Similar initialization logic but with Java-specific patterns. |
+| `stream` | `stream` | Both handle streaming with similar semantics but with improved robustness in Java. Stream mode includes more validation to prevent false recursion errors. |
+| `_put_checkpoint` | `createCheckpoint` | Similar checkpoint creation but with Java-specific implementation. |
+
+### Runner Functions (Python: langgraph/pregel/runner.py)
+
+| Python Function | Java Method | Deviations |
+|-----------------|-------------|------------|
+| `commit` | `SuperstepManager.commit` | Java implementation encapsulates in object instead of standalone function. |
+| `tick` | `SuperstepManager.tick` | Same core functionality but adapted to Java's object-oriented paradigm. |
+
+### Algorithm Functions (Python: langgraph/pregel/algo.py)
+
+| Python Function | Java Method | Deviations |
+|-----------------|-------------|------------|
+| `prepare_next_tasks` | `TaskPlanner.planTasks` | Java implementation encapsulates in object instead of standalone function. |
+| `prepare_single_task` | `TaskPlanner.planSingleTask` | Same approach but with stronger typing in Java. |
+| `apply_writes` | Multiple methods in ChannelRegistry | Java distributes responsibility across specialized classes. |
+
+## Implementation Notes
+
+### General Patterns
+- Java uses more explicit type information compared to Python
+- Builder pattern is used in Java where Python uses parameter initialization
+- Java collections (List, Map) replace Python collections (list, dict)
+- Java follows standard exception hierarchy rather than Python's exception model
+- Python's functional approach is often translated to Java's object-oriented design using objects with state
+- Uninitialized channels in Java return null or empty collections rather than throwing exceptions
+- Nodes in Java follow Python's behavior: only nodes with input channel as a trigger run in the first superstep
+- Both implementations handle uninitialized channels gracefully without requiring manual initialization
+
+### Missing Features (To Be Implemented)
+- Some stream modes are not yet fully implemented in Java
+- Advanced graph features are still under development in Java
+- Some error handling cases need refinement to match Python semantics fully
+
+## When Adding New Components
+When adding new Java classes that correspond to Python implementations:
+1. Add an entry to this document
+2. Document any deviations and justify according to allowed reasons:
+   - Different public interfaces to match Java developer expectations
+   - Different implementation details to match Java stdlib/patterns
+   - Not yet fully implemented Python behavior
+3. Never introduce deviations just to take shortcuts or change behavior

langgraph-java/README.md

@@ -0,0 +1,266 @@
+# LangGraph Java
+
+A Java implementation of the [LangGraph](https://github.com/langchain-ai/langgraph) framework for building stateful, streaming LLM applications.
+
+## Overview
+
+LangGraph Java is designed for building directed, stateful computational graphs suitable for orchestrating LLM-based applications. The framework is particularly useful for:
+
+- Building agents with tools, memory, and planning abilities
+- Creating multi-agent systems with communication channels
+- Implementing retrieval augmented generation (RAG) pipelines
+- Supporting streaming output for responsive UI experiences
+
+Key features:
+
+- **Type-safe execution** with Java generics
+- **Stateful graph execution** with checkpoint persistence
+- **Streaming output** for real-time feedback
+- **Directed computation graphs** with deterministic execution
+
+## Project Structure
+
+- `langgraph-checkpoint`: Base persistence interfaces
+- `langgraph-core`: Main library with channels, Pregel implementation
+- `langgraph-examples`: Example applications
+
+## Requirements
+
+- Java 17 or higher
+- Gradle 7.0 or higher
+
+## Building
+
+```bash
+./gradlew build
+```
+
+## Getting Started
+
+### Basic Example
+
+Here's a simple example that creates a graph with a single node that adds 1 to its input:
+
+```java
+import com.langgraph.channels.LastValue;
+import com.langgraph.pregel.Pregel;
+import com.langgraph.pregel.PregelExecutable;
+import com.langgraph.pregel.PregelNode;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class SimpleExample {
+    public static void main(String[] args) {
+        // Create a node that adds 1 to the input
+        PregelNode<Integer, Integer> node = new PregelNode.Builder<>("adder", 
+            new PregelExecutable<Integer, Integer>() {
+                @Override
+                public Map<String, Integer> execute(Map<String, Integer> inputs, Map<String, Object> context) {
+                    // Get input value, default to 0 if not present
+                    int inputValue = inputs.getOrDefault("input", 0);
+                    
+                    // Return output with value increased by 1
+                    Map<String, Integer> output = new HashMap<>();
+                    output.put("output", inputValue + 1);
+                    return output;
+                }
+            })
+            .channels("input")        // Read from "input" channel
+            .triggerChannels("input") // Triggered by "input" updates
+            .writers("output")        // Write to "output" channel
+            .build();
+        
+        // Create channels
+        Map<String, BaseChannel<?, ?, ?>> channels = new HashMap<>();
+        channels.put("input", LastValue.<Integer>create("input"));
+        channels.put("output", LastValue.<Integer>create("output"));
+        
+        // Create Pregel instance
+        Pregel<Integer, Integer> pregel = new Pregel.Builder<Integer, Integer>()
+                .addNode(node)
+                .addChannels(channels)
+                .build();
+        
+        // Run with input 5
+        Map<String, Integer> input = new HashMap<>();
+        input.put("input", 5);
+        Map<String, Integer> result = pregel.invoke(input, null);
+        
+        // Print result (should be 6)
+        System.out.println("Result: " + result.get("output"));
+    }
+}
+```
+
+### Multi-Step Graph Example
+
+Here's an example of a two-node graph that performs sequential processing:
+
+```java
+import com.langgraph.channels.BaseChannel;
+import com.langgraph.channels.LastValue;
+import com.langgraph.pregel.Pregel;
+import com.langgraph.pregel.PregelExecutable;
+import com.langgraph.pregel.PregelNode;
+
+import java.util.*;
+
+public class SequentialExample {
+    public static void main(String[] args) {
+        // First node: Add 1 to the input and write to intermediate channel
+        PregelNode<Integer, Integer> adder = new PregelNode.Builder<>("adder", 
+            new PregelExecutable<Integer, Integer>() {
+                @Override
+                public Map<String, Integer> execute(Map<String, Integer> inputs, Map<String, Object> context) {
+                    int inputValue = inputs.getOrDefault("input", 0);
+                    System.out.println("Adder received input: " + inputValue);
+                    
+                    // Add 1 to the input value
+                    int result = inputValue + 1;
+                    
+                    // Write to the intermediate channel "state"
+                    Map<String, Integer> output = new HashMap<>();
+                    output.put("state", result);
+                    return output;
+                }
+            })
+            .channels("input")
+            .triggerChannels("input")
+            .writers("state")
+            .build();
+        
+        // Second node: Multiply intermediate value by 2 and write to output
+        PregelNode<Integer, Integer> multiplier = new PregelNode.Builder<>("multiplier", 
+            new PregelExecutable<Integer, Integer>() {
+                @Override
+                public Map<String, Integer> execute(Map<String, Integer> inputs, Map<String, Object> context) {
+                    // Get state value, default to 1 if not present
+                    int stateValue = inputs.getOrDefault("state", 1);
+                    
+                    // Multiply by 2
+                    int result = stateValue * 2;
+                    
+                    // Write to the output channel
+                    Map<String, Integer> output = new HashMap<>();
+                    output.put("output", result);
+                    return output;
+                }
+            })
+            .channels("state")
+            .triggerChannels("state")
+            .writers("output")
+            .build();
+        
+        // Create and configure channels
+        Map<String, BaseChannel<?, ?, ?>> channels = new HashMap<>();
+        channels.put("input", LastValue.<Integer>create("input"));
+        channels.put("state", LastValue.<Integer>create("state"));
+        channels.put("output", LastValue.<Integer>create("output"));
+        
+        // Create Pregel instance with both nodes
+        Pregel<Integer, Integer> pregel = new Pregel.Builder<Integer, Integer>()
+                .addNode(adder)
+                .addNode(multiplier)
+                .addChannels(channels)
+                .build();
+        
+        // Run with input 5
+        Map<String, Integer> input = Collections.singletonMap("input", 5);
+        Map<String, Integer> result = pregel.invoke(input, null);
+        
+        // Print result: (5 + 1) * 2 = 12
+        System.out.println("Result: " + result.get("output"));
+    }
+}
+```
+
+## Advanced Usage
+
+### Working with String Data
+
+```java
+// Create a node that processes string data
+PregelNode<String, String> processor = new PregelNode.Builder<>("processor", 
+    new PregelExecutable<String, String>() {
+        @Override
+        public Map<String, String> execute(Map<String, String> inputs, Map<String, Object> context) {
+            String input = inputs.getOrDefault("input", "");
+            Map<String, String> output = new HashMap<>();
+            output.put("output", input.toUpperCase());
+            return output;
+        }
+    })
+    .channels("input")
+    .triggerChannels("input")
+    .writers("output")
+    .build();
+
+// Create channels
+Map<String, BaseChannel<?, ?, ?>> channels = new HashMap<>();
+channels.put("input", LastValue.<String>create("input"));
+channels.put("output", LastValue.<String>create("output"));
+
+// Create Pregel instance
+Pregel<String, String> pregel = new Pregel.Builder<String, String>()
+        .addNode(processor)
+        .addChannels(channels)
+        .build();
+```
+
+### Working with JSON-like Data
+
+```java
+// Create a node that processes Map<String, Object> data (JSON-like)
+PregelNode<Map<String, Object>, Map<String, Object>> processor = 
+    new PregelNode.Builder<>("processor", 
+        new PregelExecutable<Map<String, Object>, Map<String, Object>>() {
+            @Override
+            public Map<String, Map<String, Object>> execute(
+                    Map<String, Map<String, Object>> inputs, 
+                    Map<String, Object> context) {
+                
+                Map<String, Object> input = inputs.getOrDefault("input", Collections.emptyMap());
+                
+                // Process input
+                Map<String, Object> result = new HashMap<>(input);
+                result.put("processed", true);
+                
+                Map<String, Map<String, Object>> output = new HashMap<>();
+                output.put("output", result);
+                return output;
+            }
+        })
+        .channels("input")
+        .triggerChannels("input")
+        .writers("output")
+        .build();
+
+// Create channels
+Map<String, BaseChannel<?, ?, ?>> channels = new HashMap<>();
+channels.put("input", LastValue.<Map<String, Object>>create("input"));
+channels.put("output", LastValue.<Map<String, Object>>create("output"));
+
+// Create Pregel instance
+Pregel<Map<String, Object>, Map<String, Object>> pregel = 
+    new Pregel.Builder<Map<String, Object>, Map<String, Object>>()
+        .addNode(processor)
+        .addChannels(channels)
+        .build();
+```
+
+## Channel Types
+
+LangGraph Java provides different channel types for different use cases:
+
+- **LastValue**: Stores the last value written to the channel
+- **TopicChannel**: Collects multiple values into a list
+- **EphemeralValue**: Only available for the current execution step
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

langgraph-java/SUMMARY.md

@@ -0,0 +1,54 @@
+# Type-Safe LangGraph Java Implementation Summary
+
+## Changes Made
+
+1. **PregelExecutable<I, O> Interface**
+   - Added generic type parameters for input and output
+   - Provides strict typing for node actions
+   - Added Legacy adapter for backward compatibility
+
+2. **PregelNode<I, O> Class**
+   - Made generic to enforce type safety
+   - Added input and output type tracking
+   - Enhanced with type validation during execution
+   - Legacy factory methods for compatibility
+
+3. **PregelProtocol<I, O> Interface**
+   - Added type parameters for input and output
+   - Typed API for graph I/O
+   - Legacy subinterface for backward compatibility
+
+4. **Pregel<I, O> Class**
+   - Type-safe implementation
+   - Type validation for channels and nodes
+   - Enhanced builder pattern with types
+   - Legacy factory methods
+
+
+## Type Safety Benefits
+
+1. **Compile-time Type Checking**
+   - Input/output types checked at compile time
+   - Prevents type errors at runtime
+   - Clearer API for developers
+
+2. **Enhanced Runtime Validation**
+   - Validates type compatibility at graph construction
+   - Checks node/channel compatibility
+   - Provides clear error messages for mismatches
+
+3. **Reduced Need for Type Casting**
+   - Explicit type parameters eliminate need for casts
+   - Prevents ClassCastExceptions
+   - Better developer experience
+
+4. **Documentation & API Clarity**
+   - Type parameters document expected types
+   - Self-documenting builder pattern
+   - Clearer type relationships
+
+5. **Backward Compatibility**
+   - Legacy methods for existing code
+   - Gradual migration possible
+   - No breaking changes to existing APIs
+