Update OpenAPI spec from LangGraph API v0.4.3

2026-08-30 03:39:38 +02:00 · 2025-08-28 09:05:36 +00:00
84 changed files with 305 additions and 3718 deletions
@@ -14,25 +14,12 @@ jobs:
        python-version:
          - "3.10"
          - "3.11"
-        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
    name: "CLI integration test"
    defaults:
      run:
        working-directory: libs/cli
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
      - name: Get changed files
        id: changed-files
        uses: Ana06/get-changed-files@v2.3.0
@@ -46,51 +33,57 @@ jobs:
          enable-cache: true
          cache-suffix: "cli-integration-test"
          ignore-nothing-to-cache: true
+      - 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
        run: pip install -e .
-      - name: Build and test service ${{ matrix.example.name }}
+      - name: Build and test service A
        if: steps.changed-files.outputs.all
-        working-directory: ${{ matrix.example.workdir }}
+        working-directory: libs/cli/examples
        env:
          LANGSMITH_API_KEY: ${{ secrets.LANGSMITH_API_KEY }}
        run: |
-          # Build the image for this example
-          langgraph build -t ${{ matrix.example.tag }}
-          # 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; fi
+          # The build-arg isn't used; just testing that we accept other args
+          langgraph build -t langgraph-test-a
+          cp .env.example .env
          if [ -n "${{ secrets.LANGSMITH_API_KEY }}" ]; then echo "LANGSMITH_API_KEY=${{ secrets.LANGSMITH_API_KEY }}" >> .env; fi
-          # Run the integration test using the built tag
-          # Compute repo root to reference the shared script robustly
-          REPO_ROOT=$(git rev-parse --show-toplevel)
-          timeout 60 python "$REPO_ROOT/.github/scripts/run_langgraph_cli_test.py" -t ${{ matrix.example.tag }}
+          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
+        env:
+          LANGSMITH_API_KEY: ${{ secrets.LANGSMITH_API_KEY }}
+        run: |
+          langgraph build -t langgraph-test-b
+          cp ../.env.example .env
+          if [ -n "${{ secrets.LANGSMITH_API_KEY }}" ]; then echo "LANGSMITH_API_KEY=${{ secrets.LANGSMITH_API_KEY }}" >> .env; fi
+          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
+        env:
+          LANGSMITH_API_KEY: ${{ secrets.LANGSMITH_API_KEY }}
+        run: |
+          langgraph build -t langgraph-test-c
+          cp ../.env.example .env
+          if [ -n "${{ secrets.LANGSMITH_API_KEY }}" ]; then echo "LANGSMITH_API_KEY=${{ secrets.LANGSMITH_API_KEY }}" >> .env; fi
+          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
+        env:
+          LANGSMITH_API_KEY: ${{ secrets.LANGSMITH_API_KEY }}
+        run: |
+          langgraph build -t langgraph-test-d
+          cp ../.env.example .env
+          if [ -n "${{ secrets.LANGSMITH_API_KEY }}" ]; then echo "LANGSMITH_API_KEY=${{ secrets.LANGSMITH_API_KEY }}" >> .env; fi
+          timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-d

      - name: Build JS service
        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
-        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
-        working-directory: libs/cli/python-monorepo-example
-        run: |
-          langgraph build -t langgraph-test-g -c apps/agent/langgraph.json
-          cp apps/agent/.env.example apps/agent/.env
-          if [ -n "${{ secrets.LANGSMITH_API_KEY }}" ]; then echo "LANGSMITH_API_KEY=${{ secrets.LANGSMITH_API_KEY }}" >> apps/agent/.env; fi
-          timeout 60 python ../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-g -c apps/agent/langgraph.json
-
-      - name: Build and test prerelease reqs service
-        if: steps.changed-files.outputs.all
-        working-directory: libs/cli/examples/graph_prerelease_reqs
-        run: |
-          langgraph build -t langgraph-test-h
-          cp ../.env.example .env
-          if [ -n "${{ secrets.LANGSMITH_API_KEY }}" ]; then echo "LANGSMITH_API_KEY=${{ secrets.LANGSMITH_API_KEY }}" >> .env; fi
-          timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-h
@@ -31,7 +31,7 @@ jobs:
          - "3.12"
    name: "lint #${{ matrix.python-version }}"
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
      - name: Get changed files
        id: changed-files
        uses: Ana06/get-changed-files@v2.3.0
@@ -25,7 +25,7 @@ jobs:

    name: "test #${{ matrix.python-version }}"
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
      - name: Set up Python ${{ matrix.python-version }}
        uses: astral-sh/setup-uv@v6
        with:
@@ -23,7 +23,7 @@ jobs:
        working-directory: libs/langgraph
    name: "test #${{ matrix.python-version }}"
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
      - name: Set up Python ${{ matrix.python-version }}
        uses: astral-sh/setup-uv@v6
        with:
@@ -24,7 +24,7 @@ jobs:
      version: ${{ steps.check-version.outputs.version }}

    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4

      - name: Set up Python $${ env.PYTHON_VERSION }}
        uses: astral-sh/setup-uv@v6
@@ -75,9 +75,9 @@ jobs:
      id-token: write

    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4

-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@v4
        with:
          name: test-dist
          path: ${{ inputs.working-directory }}/dist/
@@ -17,7 +17,7 @@ jobs:
      run:
        working-directory: libs/langgraph
    steps:
-      - uses: actions/checkout@v5
+      - 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@v6
@@ -15,7 +15,7 @@ jobs:
      run:
        working-directory: libs/langgraph
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
      - id: files
        name: Get changed files
        uses: Ana06/get-changed-files@v2.3.0
@@ -27,7 +27,7 @@ jobs:
      python: ${{ steps.filter.outputs.python }}
      deps: ${{ steps.filter.outputs.deps }}
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
      - uses: dorny/paths-filter@v3
        id: filter
        with:
@@ -100,9 +100,9 @@ jobs:
    name: "Check SDK methods matching"
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v5
+      - 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
@@ -118,7 +118,7 @@ jobs:
        python-version:
          - "3.11"
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
      - name: Set up Python ${{ matrix.python-version }}
        uses: astral-sh/setup-uv@v6
        with:
@@ -21,7 +21,7 @@
    
        steps:
          - name: Checkout
-            uses: actions/checkout@v5
+            uses: actions/checkout@v4
    
          - name: Install Dependencies
            run: |
@@ -28,7 +28,7 @@ jobs:
    outputs:
      changed-files: ${{ steps.changed-files.outputs.added_modified }}
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
      - name: Get changed files
        id: changed-files
        uses: Ana06/get-changed-files@v2.3.0
@@ -41,7 +41,7 @@ jobs:
    env:
      GITHUB_TOKEN: ${{ secrets.MKDOCS_GITHUB_TOKEN }}
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

@@ -140,7 +140,7 @@ jobs:

      - name: Upload Pages Artifact
        # if: github.ref == 'refs/heads/main'
-        uses: actions/upload-pages-artifact@v4
+        uses: actions/upload-pages-artifact@v3
        with:
          path: ./docs/site/

@@ -19,7 +19,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
-        uses: actions/checkout@v5
+        uses: actions/checkout@v4
        with:
          fetch-depth: 0

@@ -36,7 +36,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
-        uses: actions/checkout@v5
+        uses: actions/checkout@v4
        with:
          fetch-depth: 1

@@ -12,7 +12,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Validate PR Title
-        uses: amannn/action-semantic-pull-request@v6
+        uses: amannn/action-semantic-pull-request@v5
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
@@ -40,7 +40,6 @@ jobs:
            sdk-py
            docs
            ci
-            deps
          requireScope: false
          ignoreLabels: |
            ignore-lint-pr-title
@@ -26,7 +26,7 @@ jobs:
      tag: ${{ steps.check-version.outputs.tag }}

    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4

      - name: Set up Python
        uses: astral-sh/setup-uv@v6
@@ -87,7 +87,7 @@ jobs:
    outputs:
      release-body: ${{ steps.generate-release-body.outputs.release-body }}
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
        with:
          repository: langchain-ai/langgraph
          path: langgraph
@@ -158,7 +158,7 @@ jobs:
      - test-pypi-publish
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4

      # We explicitly *don't* set up caching here. This ensures our tests are
      # maximally sensitive to catching breakage.
@@ -261,7 +261,7 @@ jobs:
        working-directory: ${{ inputs.working-directory }}

    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4

      - name: Set up Python
        uses: astral-sh/setup-uv@v6
@@ -270,7 +270,7 @@ jobs:
          enable-cache: true
          cache-suffix: "release"

-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@v4
        with:
          name: dist
          path: ${{ inputs.working-directory }}/dist/
@@ -302,7 +302,7 @@ jobs:
        working-directory: ${{ inputs.working-directory }}

    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4

      - name: Set up Python
        uses: astral-sh/setup-uv@v6
@@ -311,7 +311,7 @@ jobs:
          enable-cache: true
          cache-suffix: "release"

-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@v4
        with:
          name: dist
          path: ${{ inputs.working-directory }}/dist/
@@ -28,7 +28,7 @@ jobs:
          - "latest"

    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
      - name: Set up Python + Poetry
        uses: astral-sh/setup-uv@v6
        with:
@@ -16,7 +16,7 @@ jobs:
    runs-on: ubuntu-latest
    
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
      
      - name: Set up uv
        uses: astral-sh/setup-uv@v6
@@ -71,7 +71,7 @@ While LangGraph can be used standalone, it also integrates seamlessly with any L

 ## Additional resources

- [Guides](https://langchain-ai.github.io/langgraph/guides/): Quick, actionable code snippets for topics such as streaming, adding memory & persistence, and design patterns (e.g. branching, subgraphs, etc.).
+- [Guides](https://langchain-ai.github.io/langgraph/how-tos/): Quick, actionable code snippets for topics such as streaming, adding memory & persistence, and design patterns (e.g. branching, subgraphs, etc.).
 - [Reference](https://langchain-ai.github.io/langgraph/reference/graphs/): Detailed reference on core classes, methods, how to use the graph and checkpointing APIs, and higher-level prebuilt components.
 - [Examples](https://langchain-ai.github.io/langgraph/examples/): 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.
@@ -2108,9 +2108,9 @@ __metadata:
  linkType: hard

 "hono@npm:^4.5.4":
-  version: 4.9.6
-  resolution: "hono@npm:4.9.6"
-  checksum: 10c0/182a144eb3b9e05bd9e43d15af15c93f60d3d747fef6c6904b9993e9db8129ea7fadf6190331d6f76b1bf6dd2b2c3b13efea105236f541ef411397e30475422d
+  version: 4.8.9
+  resolution: "hono@npm:4.8.9"
+  checksum: 10c0/385539d1787fdc747bc869ef0e5ccc9f39cbe40289b94f23eecfc82c6ca440f059704647cd6381a5066d2cf7baa43ab25184c78d44af4c5c98a5c5b07670059e
  languageName: node
  linkType: hard

@@ -90,7 +90,7 @@ graph.invoke( # (1)!
    from langgraph.runtime import Runtime

    # highlight-next-line
-    def node(state: State, runtime: Runtime[ContextSchema]):
+    def node(state: State, config: Runtime[ContextSchema]):
        user_name = runtime.context.user_name
        ...
    ```
@@ -29,10 +29,6 @@
      "name": "Store",
      "description": "Store is an API for managing persistent key-value store (long-term memory) that is available from any thread."
    },
-    {
-      "name": "A2A",
-      "description": "Agent-to-Agent Protocol related endpoints for exposing assistants as A2A-compliant agents."
-    },
    {
      "name": "MCP",
      "description": "Model Context Protocol related endpoints for exposing an agent as an MCP server."
@@ -3186,195 +3182,6 @@
        }
      }
    },
-    "/a2a/{assistant_id}": {
-      "post": {
-        "operationId": "post_a2a",
-        "summary": "A2A Post",
-        "description": "Communicate with an assistant using the Agent-to-Agent Protocol.\nSends a JSON-RPC 2.0 message to the assistant.\n\n- **Request**: Provide an object with `jsonrpc`, `id`, `method`, and optional `params`.\n- **Response**: Returns a JSON-RPC response with task information or error.\n\n**Supported Methods:**\n- `message/send`: Send a message to the assistant\n- `tasks/get`: Get the status and result of a task\n\n**Notes:**\n- Supports threaded conversations via thread context\n- Messages can contain text and data parts\n- Tasks run asynchronously and return completion status\n",
-        "parameters": [
-          {
-            "name": "assistant_id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "format": "uuid"
-            },
-            "description": "The ID of the assistant to communicate with"
-          },
-          {
-            "name": "Accept",
-            "in": "header",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "enum": ["application/json"]
-            },
-            "description": "Must be application/json"
-          }
-        ],
-        "requestBody": {
-          "required": true,
-          "content": {
-            "application/json": {
-              "schema": {
-                "type": "object",
-                "properties": {
-                  "jsonrpc": {
-                    "type": "string",
-                    "enum": ["2.0"],
-                    "description": "JSON-RPC version"
-                  },
-                  "id": {
-                    "type": "string",
-                    "description": "Request identifier"
-                  },
-                  "method": {
-                    "type": "string",
-                    "enum": ["message/send", "tasks/get"],
-                    "description": "The method to invoke"
-                  },
-                  "params": {
-                    "type": "object",
-                    "description": "Method parameters",
-                    "oneOf": [
-                      {
-                        "title": "Message Send Parameters",
-                        "properties": {
-                          "message": {
-                            "type": "object",
-                            "properties": {
-                              "role": {
-                                "type": "string",
-                                "enum": ["user", "assistant"],
-                                "description": "Message role"
-                              },
-                              "parts": {
-                                "type": "array",
-                                "items": {
-                                  "oneOf": [
-                                    {
-                                      "title": "Text Part",
-                                      "type": "object",
-                                      "properties": {
-                                        "kind": {
-                                          "type": "string",
-                                          "enum": ["text"]
-                                        },
-                                        "text": {
-                                          "type": "string"
-                                        }
-                                      },
-                                      "required": ["kind", "text"]
-                                    },
-                                    {
-                                      "title": "Data Part", 
-                                      "type": "object",
-                                      "properties": {
-                                        "kind": {
-                                          "type": "string",
-                                          "enum": ["data"]
-                                        },
-                                        "data": {
-                                          "type": "object"
-                                        }
-                                      },
-                                      "required": ["kind", "data"]
-                                    }
-                                  ]
-                                },
-                                "description": "Message parts"
-                              },
-                              "messageId": {
-                                "type": "string",
-                                "description": "Unique message identifier"
-                              }
-                            },
-                            "required": ["role", "parts", "messageId"]
-                          },
-                          "thread": {
-                            "type": "object",
-                            "properties": {
-                              "threadId": {
-                                "type": "string",
-                                "description": "Thread identifier for conversation context"
-                              }
-                            },
-                            "description": "Optional thread context"
-                          }
-                        },
-                        "required": ["message"]
-                      },
-                      {
-                        "title": "Task Get Parameters",
-                        "properties": {
-                          "taskId": {
-                            "type": "string",
-                            "description": "Task identifier to retrieve"
-                          }
-                        },
-                        "required": ["taskId"]
-                      }
-                    ]
-                  }
-                },
-                "required": ["jsonrpc", "id", "method"]
-              }
-            }
-          }
-        },
-        "responses": {
-          "200": {
-            "description": "JSON-RPC response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "type": "object",
-                  "properties": {
-                    "jsonrpc": {
-                      "type": "string",
-                      "enum": ["2.0"]
-                    },
-                    "id": {
-                      "type": "string"
-                    },
-                    "result": {
-                      "type": "object",
-                      "description": "Success result containing task information or task details"
-                    },
-                    "error": {
-                      "type": "object",
-                      "properties": {
-                        "code": {
-                          "type": "integer"
-                        },
-                        "message": {
-                          "type": "string"
-                        }
-                      },
-                      "description": "Error information if request failed"
-                    }
-                  },
-                  "required": ["jsonrpc", "id"]
-                }
-              }
-            }
-          },
-          "400": {
-            "description": "Bad request - invalid JSON-RPC or missing Accept header"
-          },
-          "404": {
-            "description": "Assistant not found"
-          },
-          "500": {
-            "description": "Internal server error"
-          }
-        },
-        "tags": [
-          "A2A"
-        ]
-      }
-    },
    "/mcp/": {
      "post": {
        "operationId": "post_mcp",
@@ -5015,12 +4822,6 @@
      },
      "ThreadSearchRequest": {
        "properties": {
-          "ids": {
-            "type": "array",
-            "items": {"type": "string", "format": "uuid"},
-            "title": "Ids",
-            "description": "List of thread IDs to include. Others are excluded."
-          },
          "metadata": {
            "type": "object",
            "title": "Metadata",
@@ -5261,30 +5062,11 @@
            "type": "object",
            "title": "Metadata",
            "description": "Metadata to merge with existing thread metadata."
-          },
-          "ttl": {
-            "type": "object",
-            "title": "TTL",
-            "description": "The time-to-live for the thread.",
-            "properties": {
-              "strategy": {
-                "type": "string",
-                "enum": [
-                  "delete"
-                ],
-                "description": "The TTL strategy. 'delete' removes the entire thread.",
-                "default": "delete"
-              },
-              "ttl": {
-                "type": "number",
-                "description": "The time-to-live in minutes from now until thread should be swept."
-              }
-            }
          }
        },
        "type": "object",
        "title": "ThreadPatch",
-        "description": "Payload for updating a thread."
+        "description": "Payload for creating a thread."
      },
      "ThreadStateCheckpointRequest": {
        "properties": {
@@ -483,19 +483,19 @@ The LangGraph CLI requires a JSON configuration file that follows this [schema](

    RUN PIP_CONFIG_FILE=/pipconfig.txt PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir -c /api/constraints.txt langchain_community langchain_anthropic langchain_openai wikipedia scikit-learn

-    ADD ./graphs /deps/outer-graphs/src
+    ADD ./graphs /deps/__outer_graphs/src
    RUN set -ex && \
        for line in '[project]' \
                    'name = "graphs"' \
                    'version = "0.1"' \
                    '[tool.setuptools.package-data]' \
                    '"*" = ["**/*"]'; do \
-            echo "$line" >> /deps/outer-graphs/pyproject.toml; \
+            echo "$line" >> /deps/__outer_graphs/pyproject.toml; \
        done

    RUN PIP_CONFIG_FILE=/pipconfig.txt PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir -c /api/constraints.txt -e /deps/*

-    ENV LANGSERVE_GRAPHS='{"agent": "/deps/outer-graphs/src/agent.py:graph", "storm": "/deps/outer-graphs/src/storm.py:graph"}'
+    ENV LANGSERVE_GRAPHS='{"agent": "/deps/__outer_graphs/src/agent.py:graph", "storm": "/deps/__outer_graphs/src/storm.py:graph"}'
    ```

    ???+ note "Updating your langgraph.json file"
@@ -1040,7 +1040,7 @@ def node_a(state: State, runtime: Runtime[ContextSchema]):
    ...
 ```

-See [this guide](../how-tos/graph-api.md#add-runtime-configuration) for a full breakdown on configuration.
+See [this guide](../how-tos/graph-api.ipynb#add-runtime-configuration) for a full breakdown on configuration.
 :::

 :::js
@@ -134,7 +134,7 @@ def update_instructions(state: State, store: BaseStore):
    namespace = ("instructions",)
    current_instructions = store.search(namespace)[0]
    # Memory logic
-    prompt = prompt_template.format(instructions=current_instructions.value["instructions"], conversation=state["messages"])
+    prompt = prompt_template.format(instructions=instructions.value["instructions"], conversation=state["messages"])
    output = llm.invoke(prompt)
    new_instructions = output['new_instructions']
    store.put(("agent_instructions",), "agent_a", {"instructions": new_instructions})
@@ -278,4 +278,4 @@ const items = await store.search(
 ```
 :::

-For more information about the memory store, see the [Persistence](persistence.md#memory-store) guide.
+For more information about the memory store, see the [Persistence](persistence.md#memory-store) guide.
@@ -897,5 +897,5 @@ There are two high-level approaches to achieve that:

 An agent might need to have a different state schema from the rest of the agents. For example, a search agent might only need to keep track of queries and retrieved documents. There are two ways to achieve this in LangGraph:

- Define [subgraph](./subgraphs.md) agents with a separate state schema. If there are no shared state keys (channels) between the subgraph and the parent graph, it's important to [add input / output transformations](../how-tos/subgraph.md#different-state-schemas) so that the parent graph knows how to communicate with the subgraphs.
- Define agent node functions with a [private input state schema](../how-tos/graph-api.md#pass-private-state-between-nodes) that is distinct from the overall graph state schema. This allows passing information that is only needed for executing that particular agent.
+- Define [subgraph](./subgraphs.md) agents with a separate state schema. If there are no shared state keys (channels) between the subgraph and the parent graph, it's important to [add input / output transformations](../how-tos/subgraph.ipynb#different-state-schemas) so that the parent graph knows how to communicate with the subgraphs.
+- Define agent node functions with a [private input state schema](../how-tos/graph-api.ipynb#pass-private-state-between-nodes) that is distinct from the overall graph state schema. This allows passing information that is only needed for executing that particular agent.
@@ -1019,7 +1019,7 @@ console.log(await graph.invoke({}, { configurable: { myRuntimeValue: "b" } }));
    # Usage
    input_message = {"role": "user", "content": "hi"}
    # With no configuration, uses default (Anthropic)
-    response_1 = graph.invoke({"messages": [input_message]}, context=ContextSchema())["messages"][-1]
+    response_1 = graph.invoke({"messages": [input_message]})["messages"][-1]
    # Or, can set OpenAI
    response_2 = graph.invoke({"messages": [input_message]}, context={"model_provider": "openai"})["messages"][-1]

@@ -1205,7 +1205,7 @@ There are many use cases where you may wish for your node to have a custom retry
 To configure a retry policy, pass the `retry_policy` parameter to the [add_node](../reference/graphs.md#langgraph.graph.state.StateGraph.add_node). The `retry_policy` parameter takes in a `RetryPolicy` named tuple object. Below we instantiate a `RetryPolicy` object with the default parameters and associate it with a node:

 ```python
-from langgraph.types import RetryPolicy
+from langgraph.pregel import RetryPolicy

 builder.add_node(
    "node_name",
@@ -1260,7 +1260,7 @@ By default, the retry policy retries on any exception except for the following:
    from typing_extensions import TypedDict
    from langchain.chat_models import init_chat_model
    from langgraph.graph import END, MessagesState, StateGraph, START
-    from langgraph.types import RetryPolicy
+    from langgraph.pregel import RetryPolicy
    from langchain_community.utilities import SQLDatabase
    from langchain_core.messages import AIMessage

@@ -1422,15 +1422,15 @@ const builder = new StateGraph(State)
 :::

 ??? info "Why split application steps into a sequence with LangGraph?"
-    LangGraph makes it easy to add an underlying persistence layer to your application.
-    This allows state to be checkpointed in between the execution of nodes, so your LangGraph nodes govern:
+LangGraph makes it easy to add an underlying persistence layer to your application.
+This allows state to be checkpointed in between the execution of nodes, so your LangGraph nodes govern:

- How state updates are [checkpointed](../concepts/persistence.md)
- How interruptions are resumed in [human-in-the-loop](../concepts/human_in_the_loop.md) workflows
- How we can "rewind" and branch-off executions using LangGraph's [time travel](../concepts/time-travel.md) features
+    - How state updates are [checkpointed](../concepts/persistence.md)
+    - How interruptions are resumed in [human-in-the-loop](../concepts/human_in_the_loop.md) workflows
+    - How we can "rewind" and branch-off executions using LangGraph's [time travel](../concepts/time-travel.md) features

-They also determine how execution steps are [streamed](../concepts/streaming.md), and how your application is visualized
-and debugged using [LangGraph Studio](../concepts/langgraph_studio.md).
+    They also determine how execution steps are [streamed](../concepts/streaming.md), and how your application is visualized
+    and debugged using [LangGraph Studio](../concepts/langgraph_studio.md).

 Let's demonstrate an end-to-end example. We will create a sequence of three steps:

@@ -2110,6 +2110,7 @@ builder.add_edge(START, "generate_topics")
 builder.add_conditional_edges("generate_topics", continue_to_jokes, ["generate_joke"])
 builder.add_edge("generate_joke", "best_joke")
 builder.add_edge("best_joke", END)
+builder.add_edge("generate_topics", END)
 graph = builder.compile()
 ```

@@ -2332,7 +2333,7 @@ from IPython.display import Image, display
 display(Image(graph.get_graph().draw_mermaid_png()))
 ```

-![Simple loop graph](assets/graph_api_image_7.png)
+![Simple loop graph](assets/graph_api_image_3.png)
 :::

 :::js
@@ -3271,7 +3272,7 @@ from langchain_core.runnables.graph import CurveStyle, MermaidDrawMethod, NodeSt
 display(Image(app.get_graph().draw_mermaid_png()))
 ```

-![Fractal graph visualization](assets/graph_api_image_10.png)
+![Fractal graph visualization](assets/graph_api_image_5.png)

 **Using Mermaid + Pyppeteer**

@@ -3319,4 +3320,4 @@ const imageBuffer = new Uint8Array(await image.arrayBuffer());

 await fs.writeFile("graph.png", imageBuffer);
 ```
-:::
+:::
@@ -366,8 +366,8 @@ result = graph.invoke(

 # Resume with mapping of interrupt IDs to values
 resume_map = {
-    i.id: f"edited text for {i.value['text_to_revise']}"
-    for i in graph.get_state(config).interrupts
+    i.interrupt_id: f"human input for prompt {i.value}"
+    for i in parent.get_state(thread_config).interrupts
 }
 print(graph.invoke(Command(resume=resume_map), config=config))
 # > {'text_1': 'edited text for original text 1', 'text_2': 'edited text for original text 2'}
@@ -1948,7 +1948,7 @@ const llmWithTools = llm.bindTools(tools);


    # Conditional edge function to route to the tool node or end based upon whether the LLM made a tool call
-    def should_continue(state: MessagesState) -> Literal["Action", END]:
+    def should_continue(state: MessagesState) -> Literal["environment", END]:
        """Decide if we should continue the loop or stop based upon whether the LLM made a tool call"""

        messages = state["messages"]
@@ -707,9 +707,7 @@
    "    \"\"\"\n",
    "    Find all tool calls in the messages returned\n",
    "    \"\"\"\n",
-    "    tool_calls = [\n",
-    "        tc[\"name\"] for m in messages[\"messages\"] for tc in getattr(m, \"tool_calls\", [])\n",
-    "    ]\n",
+    "    tool_calls = [tc['name'] for m in messages['messages'] for tc in getattr(m, 'tool_calls', [])]\n",
    "    return tool_calls\n",
    "\n",
    "\n",
@@ -861,46 +861,3 @@ def test_store_ttl(store):
    # Now has been (TTL_SECONDS-2)*2 > TTL_SECONDS + TTL_SECONDS/2
    res = store.search(ns, query="bar", refresh_ttl=False)
    assert len(res) == 0
-
-
-@pytest.mark.parametrize(
-    "vector_type,distance_type",
-    [
-        ("vector", "cosine"),
-        ("vector", "inner_product"),
-        ("halfvec", "cosine"),
-        ("halfvec", "inner_product"),
-    ],
-)
-def test_non_ascii(
-    request: Any,
-    fake_embeddings: CharacterEmbeddings,
-    vector_type: str,
-    distance_type: str,
-) -> None:
-    """Test support for non-ascii characters"""
-    with _create_vector_store(
-        vector_type,
-        distance_type,
-        fake_embeddings
-    ) as store:
-    
-        store.put(("user_123", "memories"), "1", {"text": "这是中文"})  # Chinese
-        store.put(
-            ("user_123", "memories"), "2", {"text": "これは日本語です"}
-        )  # Japanese
-        store.put(("user_123", "memories"), "3", {"text": "이건 한국어야"})  # Korean
-        store.put(("user_123", "memories"), "4", {"text": "Это русский"})  # Russian
-        store.put(("user_123", "memories"), "5", {"text": "यह रूसी है"})  # Hindi
-
-        result1 = store.search(("user_123", "memories"), query="这是中文")
-        result2 = store.search(("user_123", "memories"), query="これは日本語です")
-        result3 = store.search(("user_123", "memories"), query="이건 한국어야")
-        result4 = store.search(("user_123", "memories"), query="Это русский")
-        result5 = store.search(("user_123", "memories"), query="यह रूसी है")
-
-        assert result1[0].key == "1"
-        assert result2[0].key == "2"
-        assert result3[0].key == "3"
-        assert result4[0].key == "4"
-        assert result5[0].key == "5"
@@ -1067,31 +1067,3 @@ def test_sql_injection_vulnerability(store: SqliteStore) -> None:

    with pytest.raises(ValueError, match="Invalid filter key"):
        store.search(("docs",), filter={malicious_key: "dummy"})
-
-
-@pytest.mark.parametrize("distance_type", VECTOR_TYPES)
-def test_non_ascii(
-    fake_embeddings: CharacterEmbeddings,
-    distance_type: str,
-) -> None:
-    """Test support for non-ascii characters"""
-    with create_vector_store(fake_embeddings, distance_type=distance_type) as store:
-        store.put(("user_123", "memories"), "1", {"text": "这是中文"})  # Chinese
-        store.put(
-            ("user_123", "memories"), "2", {"text": "これは日本語です"}
-        )  # Japanese
-        store.put(("user_123", "memories"), "3", {"text": "이건 한국어야"})  # Korean
-        store.put(("user_123", "memories"), "4", {"text": "Это русский"})  # Russian
-        store.put(("user_123", "memories"), "5", {"text": "यह रूसी है"})  # Hindi
-
-        result1 = store.search(("user_123", "memories"), query="这是中文")
-        result2 = store.search(("user_123", "memories"), query="これは日本語です")
-        result3 = store.search(("user_123", "memories"), query="이건 한국어야")
-        result4 = store.search(("user_123", "memories"), query="Это русский")
-        result5 = store.search(("user_123", "memories"), query="यह रूसी है")
-
-        assert result1[0].key == "1"
-        assert result2[0].key == "2"
-        assert result3[0].key == "3"
-        assert result4[0].key == "4"
-        assert result5[0].key == "5"
@@ -238,7 +238,7 @@ def get_text_at_path(obj: Any, path: str | list[str]) -> list[str]:
        - Nested paths in multi-field: "{field1,nested.field2}"
    """
    if not path or path == "$":
-        return [json.dumps(obj, sort_keys=True, ensure_ascii=False)]
+        return [json.dumps(obj, sort_keys=True)]

    tokens = tokenize_path(path) if isinstance(path, str) else path

@@ -249,7 +249,7 @@ def get_text_at_path(obj: Any, path: str | list[str]) -> list[str]:
            elif obj is None:
                return []
            elif isinstance(obj, (list, dict)):
-                return [json.dumps(obj, sort_keys=True, ensure_ascii=False)]
+                return [json.dumps(obj, sort_keys=True)]
            return []

        token = tokens[pos]
@@ -295,11 +295,7 @@ def get_text_at_path(obj: Any, path: str | list[str]) -> list[str]:
                        if isinstance(current_obj, (str, int, float, bool)):
                            results.append(str(current_obj))
                        elif isinstance(current_obj, (list, dict)):
-                            results.append(
-                                json.dumps(
-                                    current_obj, sort_keys=True, ensure_ascii=False
-                                )
-                            )
+                            results.append(json.dumps(current_obj, sort_keys=True))

        # Handle wildcard
        elif token == "*":
@@ -5,13 +5,12 @@ import time
 import pytest
 import redis

-from langgraph.cache.base import FullKey
 from langgraph.cache.redis import RedisCache


 class TestRedisCache:
    @pytest.fixture(autouse=True)
-    def setup(self) -> None:
+    def setup(self):
        """Set up test Redis client and cache."""
        self.client = redis.Redis(
            host="localhost", port=6379, db=0, decode_responses=False
@@ -21,21 +20,21 @@ class TestRedisCache:
        except redis.ConnectionError:
            pytest.skip("Redis server not available")

-        self.cache: RedisCache = RedisCache(self.client, prefix="test:cache:")
+        self.cache = RedisCache(self.client, prefix="test:cache:")

        # Clean up before each test
        self.client.flushdb()

-    def teardown_method(self) -> None:
+    def teardown_method(self):
        """Clean up after each test."""
        try:
            self.client.flushdb()
        except Exception:
            pass

-    def test_basic_set_and_get(self) -> None:
+    def test_basic_set_and_get(self):
        """Test basic set and get operations."""
-        keys: list[FullKey] = [(("graph", "node"), "key1")]
+        keys = [(("graph", "node"), "key1")]
        values = {keys[0]: ({"result": 42}, None)}

        # Set value
@@ -46,9 +45,9 @@ class TestRedisCache:
        assert len(result) == 1
        assert result[keys[0]] == {"result": 42}

-    def test_batch_operations(self) -> None:
+    def test_batch_operations(self):
        """Test batch set and get operations."""
-        keys: list[FullKey] = [
+        keys = [
            (("graph", "node1"), "key1"),
            (("graph", "node2"), "key2"),
            (("other", "node"), "key3"),
@@ -69,9 +68,9 @@ class TestRedisCache:
        assert result[keys[1]] == {"result": 2}
        assert result[keys[2]] == {"result": 3}

-    def test_ttl_behavior(self) -> None:
+    def test_ttl_behavior(self):
        """Test TTL (time-to-live) functionality."""
-        key: FullKey = (("graph", "node"), "ttl_key")
+        key = (("graph", "node"), "ttl_key")
        values = {key: ({"data": "expires_soon"}, 1)}  # 1 second TTL

        # Set with TTL
@@ -89,10 +88,10 @@ class TestRedisCache:
        result = self.cache.get([key])
        assert len(result) == 0

-    def test_namespace_isolation(self) -> None:
+    def test_namespace_isolation(self):
        """Test that different namespaces are isolated."""
-        key1: FullKey = (("graph1", "node"), "same_key")
-        key2: FullKey = (("graph2", "node"), "same_key")
+        key1 = (("graph1", "node"), "same_key")
+        key2 = (("graph2", "node"), "same_key")

        values = {key1: ({"graph": 1}, None), key2: ({"graph": 2}, None)}

@@ -102,12 +101,9 @@ class TestRedisCache:
        assert result[key1] == {"graph": 1}
        assert result[key2] == {"graph": 2}

-    def test_clear_all(self) -> None:
+    def test_clear_all(self):
        """Test clearing all cached values."""
-        keys: list[FullKey] = [
-            (("graph", "node1"), "key1"),
-            (("graph", "node2"), "key2"),
-        ]
+        keys = [(("graph", "node1"), "key1"), (("graph", "node2"), "key2")]
        values = {keys[0]: ({"result": 1}, None), keys[1]: ({"result": 2}, None)}

        self.cache.set(values)
@@ -123,9 +119,9 @@ class TestRedisCache:
        result = self.cache.get(keys)
        assert len(result) == 0

-    def test_clear_by_namespace(self) -> None:
+    def test_clear_by_namespace(self):
        """Test clearing cached values by namespace."""
-        keys: list[FullKey] = [
+        keys = [
            (("graph1", "node"), "key1"),
            (("graph2", "node"), "key2"),
            (("graph1", "other"), "key3"),
@@ -146,7 +142,7 @@ class TestRedisCache:
        assert len(result) == 1
        assert result[keys[1]] == {"result": 2}

-    def test_empty_operations(self) -> None:
+    def test_empty_operations(self):
        """Test behavior with empty keys/values."""
        # Empty get
        result = self.cache.get([])
@@ -155,14 +151,14 @@ class TestRedisCache:
        # Empty set
        self.cache.set({})  # Should not raise error

-    def test_nonexistent_keys(self) -> None:
+    def test_nonexistent_keys(self):
        """Test getting keys that don't exist."""
-        keys: list[FullKey] = [(("graph", "node"), "nonexistent")]
+        keys = [(("graph", "node"), "nonexistent")]
        result = self.cache.get(keys)
        assert len(result) == 0

    @pytest.mark.asyncio
-    async def test_async_operations(self) -> None:
+    async def test_async_operations(self):
        """Test async set and get operations with sync Redis client."""
        # Create sync Redis client and cache (like main integration tests)
        client = redis.Redis(host="localhost", port=6379, db=1, decode_responses=False)
@@ -171,9 +167,9 @@ class TestRedisCache:
        except Exception:
            pytest.skip("Redis not available")

-        cache: RedisCache = RedisCache(client, prefix="test:async:")
+        cache = RedisCache(client, prefix="test:async:")

-        keys: list[FullKey] = [(("graph", "node"), "async_key")]
+        keys = [(("graph", "node"), "async_key")]
        values = {keys[0]: ({"async": True}, None)}

        # Async set (delegates to sync)
@@ -188,7 +184,7 @@ class TestRedisCache:
        client.flushdb()

    @pytest.mark.asyncio
-    async def test_async_clear(self) -> None:
+    async def test_async_clear(self):
        """Test async clear operations with sync Redis client."""
        # Create sync Redis client and cache (like main integration tests)
        client = redis.Redis(host="localhost", port=6379, db=1, decode_responses=False)
@@ -197,9 +193,9 @@ class TestRedisCache:
        except Exception:
            pytest.skip("Redis not available")

-        cache: RedisCache = RedisCache(client, prefix="test:async:")
+        cache = RedisCache(client, prefix="test:async:")

-        keys: list[FullKey] = [(("graph", "node"), "key")]
+        keys = [(("graph", "node"), "key")]
        values = {keys[0]: ({"data": "test"}, None)}

        await cache.aset(values)
@@ -218,44 +214,44 @@ class TestRedisCache:
        # Cleanup
        client.flushdb()

-    def test_redis_unavailable_get(self) -> None:
+    def test_redis_unavailable_get(self):
        """Test behavior when Redis is unavailable during get operations."""
        # Create cache with non-existent Redis server
        bad_client = redis.Redis(
            host="nonexistent", port=9999, socket_connect_timeout=0.1
        )
-        cache: RedisCache = RedisCache(bad_client, prefix="test:cache:")
+        cache = RedisCache(bad_client, prefix="test:cache:")

-        keys: list[FullKey] = [(("graph", "node"), "key")]
+        keys = [(("graph", "node"), "key")]
        result = cache.get(keys)

        # Should return empty dict when Redis unavailable
        assert result == {}

-    def test_redis_unavailable_set(self) -> None:
+    def test_redis_unavailable_set(self):
        """Test behavior when Redis is unavailable during set operations."""
        # Create cache with non-existent Redis server
        bad_client = redis.Redis(
            host="nonexistent", port=9999, socket_connect_timeout=0.1
        )
-        cache: RedisCache = RedisCache(bad_client, prefix="test:cache:")
+        cache = RedisCache(bad_client, prefix="test:cache:")

-        keys: list[FullKey] = [(("graph", "node"), "key")]
+        keys = [(("graph", "node"), "key")]
        values = {keys[0]: ({"data": "test"}, None)}

        # Should not raise exception when Redis unavailable
        cache.set(values)  # Should silently fail

    @pytest.mark.asyncio
-    async def test_redis_unavailable_async(self) -> None:
+    async def test_redis_unavailable_async(self):
        """Test async behavior when Redis is unavailable."""
        # Create sync cache with non-existent Redis server (like main integration tests)
        bad_client = redis.Redis(
            host="nonexistent", port=9999, socket_connect_timeout=0.1
        )
-        cache: RedisCache = RedisCache(bad_client, prefix="test:cache:")
+        cache = RedisCache(bad_client, prefix="test:cache:")

-        keys: list[FullKey] = [(("graph", "node"), "key")]
+        keys = [(("graph", "node"), "key")]
        values = {keys[0]: ({"data": "test"}, None)}

        # Should return empty dict for get (delegates to sync)
@@ -265,10 +261,10 @@ class TestRedisCache:
        # Should not raise exception for set (delegates to sync)
        await cache.aset(values)  # Should silently fail

-    def test_corrupted_data_handling(self) -> None:
+    def test_corrupted_data_handling(self):
        """Test handling of corrupted data in Redis."""
        # Set some valid data first
-        keys: list[FullKey] = [(("graph", "node"), "valid_key")]
+        keys = [(("graph", "node"), "valid_key")]
        values = {keys[0]: ({"data": "valid"}, None)}
        self.cache.set(values)

@@ -277,36 +273,33 @@ class TestRedisCache:
        self.client.set(corrupted_key, b"invalid:data:format:too:many:colons")

        # Should skip corrupted entry and return only valid ones
-        all_keys: list[FullKey] = [keys[0], (("graph", "node"), "corrupted_key")]
+        all_keys = [keys[0], (("graph", "node"), "corrupted_key")]
        result = self.cache.get(all_keys)

        assert len(result) == 1
        assert result[keys[0]] == {"data": "valid"}

-    def test_key_parsing_edge_cases(self) -> None:
+    def test_key_parsing_edge_cases(self):
        """Test key parsing with edge cases."""
        # Test empty namespace
-        key1: FullKey = ((), "empty_ns")
+        key1 = ((), "empty_ns")
        values = {key1: ({"data": "empty_ns"}, None)}
        self.cache.set(values)
        result = self.cache.get([key1])
        assert result[key1] == {"data": "empty_ns"}

        # Test namespace with special characters
-        key2: FullKey = (
-            ("graph:with:colons", "node-with-dashes"),
-            "key_with_underscores",
-        )
+        key2 = (("graph:with:colons", "node-with-dashes"), "key_with_underscores")
        values = {key2: ({"data": "special_chars"}, None)}
        self.cache.set(values)
        result = self.cache.get([key2])
        assert result[key2] == {"data": "special_chars"}

-    def test_large_data_serialization(self) -> None:
+    def test_large_data_serialization(self):
        """Test handling of large data objects."""
        # Create a large data structure
        large_data = {"large_list": list(range(1000)), "nested": {"data": "x" * 1000}}
-        key: FullKey = (("graph", "node"), "large_key")
+        key = (("graph", "node"), "large_key")
        values = {key: (large_data, None)}

        self.cache.set(values)
@@ -1021,27 +1021,3 @@ async def test_embed_with_path(fake_embeddings: CharacterEmbeddings) -> None:
    assert len(results) == 3
    doc5_result = next(r for r in results if r.key == "doc5")
    assert doc5_result.score is None
-
-
-def test_non_ascii(fake_embeddings: CharacterEmbeddings) -> None:
-    """Test support for non-ascii characters"""
-    store = InMemoryStore(
-        index={"dims": fake_embeddings.dims, "embed": fake_embeddings}
-    )
-    store.put(("user_123", "memories"), "1", {"text": "这是中文"})  # Chinese
-    store.put(("user_123", "memories"), "2", {"text": "これは日本語です"})  # Japanese
-    store.put(("user_123", "memories"), "3", {"text": "이건 한국어야"})  # Korean
-    store.put(("user_123", "memories"), "4", {"text": "Это русский"})  # Russian
-    store.put(("user_123", "memories"), "5", {"text": "यह रूसी है"})  # Hindi
-
-    result1 = store.search(("user_123", "memories"), query="这是中文")
-    result2 = store.search(("user_123", "memories"), query="これは日本語です")
-    result3 = store.search(("user_123", "memories"), query="이건 한국어야")
-    result4 = store.search(("user_123", "memories"), query="Это русский")
-    result5 = store.search(("user_123", "memories"), query="यह रूसी है")
-
-    assert result1[0].key == "1"
-    assert result2[0].key == "2"
-    assert result3[0].key == "3"
-    assert result4[0].key == "4"
-    assert result5[0].key == "5"
@@ -1,95 +0,0 @@
-from collections.abc import Sequence
-from typing import Annotated, Literal, TypedDict
-
-from langchain.chat_models import init_chat_model
-from langchain_community.tools.tavily_search import TavilySearchResults
-from langchain_core.messages import BaseMessage
-from langchain_openai import ChatOpenAI
-from langgraph.graph import END, StateGraph, add_messages
-from langgraph.prebuilt import ToolNode
-
-tools = [TavilySearchResults(max_results=1)]
-
-model_anth = init_chat_model("claude-3-7-sonnet-20250219", model_provider="anthropic")
-model_oai = ChatOpenAI(temperature=0)
-
-model_anth = model_anth.bind_tools(tools)
-model_oai = model_oai.bind_tools(tools)
-
-
-class AgentState(TypedDict):
-    messages: Annotated[Sequence[BaseMessage], add_messages]
-
-
-# Define the function that determines whether to continue or not
-def should_continue(state):
-    messages = state["messages"]
-    last_message = messages[-1]
-    # If there are no tool calls, then we finish
-    if not last_message.tool_calls:
-        return "end"
-    # Otherwise if there is, we continue
-    else:
-        return "continue"
-
-
-# Define the function that calls the model
-def call_model(state, config):
-    if config["configurable"].get("model", "anthropic") == "anthropic":
-        model = model_anth
-    else:
-        model = model_oai
-    messages = state["messages"]
-    response = model.invoke(messages)
-    # We return a list, because this will get added to the existing list
-    return {"messages": [response]}
-
-
-# Define the function to execute tools
-tool_node = ToolNode(tools)
-
-
-class ContextSchema(TypedDict):
-    model: Literal["anthropic", "openai"]
-
-
-# Define a new graph
-workflow = StateGraph(AgentState, context_schema=ContextSchema)
-
-# Define the two nodes we will cycle between
-workflow.add_node("agent", call_model)
-workflow.add_node("action", tool_node)
-
-# Set the entrypoint as `agent`
-# This means that this node is the first one called
-workflow.set_entry_point("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,
-    # Finally we pass in a mapping.
-    # The keys are strings, and the values are other nodes.
-    # END is a special node marking that the graph should finish.
-    # What will happen is we will call `should_continue`, and then the output of that
-    # will be matched against the keys in this mapping.
-    # Based on which one it matches, that node will then be called.
-    {
-        # If `tools`, then we call the tool node.
-        "continue": "action",
-        # Otherwise we finish.
-        "end": END,
-    },
-)
-
-# 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("action", "agent")
-
-# Finally, we compile it!
-# This compiles it into a LangChain Runnable,
-# meaning you can use it as you would any other runnable
-graph = workflow.compile()
@@ -1,11 +0,0 @@
-{
-    "python_version": "3.12",
-    "dependencies": [
-      "."
-    ],
-    "graphs": {
-      "agent": "./agent.py:graph"
-    },
-    "env": "../.env"
-  }
-  
@@ -1,6 +0,0 @@
-requests
-langchain_anthropic
-langchain_openai
-langchain_community
-langchain
-langgraph==1.0.0a2
@@ -7,7 +7,6 @@ from langchain_core.messages import BaseMessage
 from langchain_openai import ChatOpenAI
 from langgraph.graph import END, StateGraph, add_messages
 from langgraph.prebuilt import ToolNode
-from langgraph.runtime import Runtime

 tools = [TavilySearchResults(max_results=1)]

@@ -18,10 +17,6 @@ model_anth = model_anth.bind_tools(tools)
 model_oai = model_oai.bind_tools(tools)


-class AgentContext(TypedDict):
-    model: Literal["anthropic", "openai"]
-
-
 class AgentState(TypedDict):
    messages: Annotated[Sequence[BaseMessage], add_messages]

@@ -39,8 +34,8 @@ def should_continue(state):


 # Define the function that calls the model
-def call_model(state, runtime: Runtime[AgentContext]):
-    if runtime.context.get("model", "anthropic") == "anthropic":
+def call_model(state, config):
+    if config["configurable"].get("model", "anthropic") == "anthropic":
        model = model_anth
    else:
        model = model_oai
@@ -54,8 +49,12 @@ def call_model(state, runtime: Runtime[AgentContext]):
 tool_node = ToolNode(tools)


+class ContextSchema(TypedDict):
+    model: Literal["anthropic", "openai"]
+
+
 # Define a new graph
-workflow = StateGraph(AgentState, context_schema=AgentContext)
+workflow = StateGraph(AgentState, context_schema=ContextSchema)

 # Define the two nodes we will cycle between
 workflow.add_node("agent", call_model)
@@ -1,6 +1,6 @@
 from collections.abc import Sequence
 from pathlib import Path
-from typing import Annotated, Literal, TypedDict
+from typing import Annotated, TypedDict

 from langchain_anthropic import ChatAnthropic
 from langchain_community.tools.tavily_search import TavilySearchResults
@@ -8,7 +8,6 @@ from langchain_core.messages import BaseMessage
 from langchain_openai import ChatOpenAI
 from langgraph.graph import END, StateGraph, add_messages
 from langgraph.prebuilt import ToolNode
-from langgraph.runtime import Runtime

 tools = [TavilySearchResults(max_results=1)]

@@ -22,10 +21,6 @@ prompt = open(Path(__file__).parent.parent / "prompt.txt").read()
 subprompt = open(Path(__file__).parent / "subprompt.txt").read()


-class AgentContext(TypedDict):
-    model: Literal["anthropic", "openai"]
-
-
 class AgentState(TypedDict):
    messages: Annotated[Sequence[BaseMessage], add_messages]

@@ -43,8 +38,8 @@ def should_continue(state):


 # Define the function that calls the model
-def call_model(state, runtime: Runtime[AgentContext]):
-    if runtime.context.get("model", "anthropic") == "anthropic":
+def call_model(state, config):
+    if config["configurable"].get("model", "anthropic") == "anthropic":
        model = model_anth
    else:
        model = model_oai
@@ -57,8 +52,9 @@ def call_model(state, runtime: Runtime[AgentContext]):
 # Define the function to execute tools
 tool_node = ToolNode(tools)

+
 # Define a new graph
-workflow = StateGraph(AgentState, context_schema=AgentContext)
+workflow = StateGraph(AgentState)

 # Define the two nodes we will cycle between
 workflow.add_node("agent", call_model)
@@ -1,6 +1,6 @@
 from collections.abc import Sequence
 from pathlib import Path
-from typing import Annotated, Literal, TypedDict
+from typing import Annotated, TypedDict

 from langchain_anthropic import ChatAnthropic
 from langchain_community.tools.tavily_search import TavilySearchResults
@@ -8,7 +8,6 @@ from langchain_core.messages import BaseMessage
 from langchain_openai import ChatOpenAI
 from langgraph.graph import END, StateGraph, add_messages
 from langgraph.prebuilt import ToolNode
-from langgraph.runtime import Runtime

 tools = [TavilySearchResults(max_results=1)]

@@ -22,10 +21,6 @@ prompt = open(Path(__file__).parent.parent / "prompt.txt").read()
 subprompt = open(Path(__file__).parent / "subprompt.txt").read()


-class AgentContext(TypedDict):
-    model: Literal["anthropic", "openai"]
-
-
 class AgentState(TypedDict):
    messages: Annotated[Sequence[BaseMessage], add_messages]

@@ -43,8 +38,8 @@ def should_continue(state):


 # Define the function that calls the model
-def call_model(state, runtime: Runtime[AgentContext]):
-    if runtime.context.get("model", "anthropic") == "anthropic":
+def call_model(state, config):
+    if config["configurable"].get("model", "anthropic") == "anthropic":
        model = model_anth
    else:
        model = model_oai
@@ -59,7 +54,7 @@ tool_node = ToolNode(tools)


 # Define a new graph
-workflow = StateGraph(AgentState, context_schema=AgentContext)
+workflow = StateGraph(AgentState)

 # Define the two nodes we will cycle between
 workflow.add_node("agent", call_model)
@@ -1,62 +0,0 @@
-module.exports = {
-  extends: [
-    "eslint:recommended",
-    "prettier",
-    "plugin:@typescript-eslint/recommended",
-  ],
-  parserOptions: {
-    ecmaVersion: 12,
-    parser: "@typescript-eslint/parser",
-    project: "./tsconfig.json",
-    sourceType: "module",
-  },
-  plugins: ["import", "@typescript-eslint", "no-instanceof"],
-  ignorePatterns: [
-    ".eslintrc.cjs",
-    "scripts",
-    "src/utils/lodash/*",
-    "node_modules",
-    "dist",
-    "dist-cjs",
-    "*.js",
-    "*.cjs",
-    "*.d.ts",
-  ],
-  rules: {
-    "no-process-env": 2,
-    "no-instanceof/no-instanceof": 2,
-    "@typescript-eslint/explicit-module-boundary-types": 0,
-    "@typescript-eslint/no-empty-function": 0,
-    "@typescript-eslint/no-shadow": 0,
-    "@typescript-eslint/no-empty-interface": 0,
-    "@typescript-eslint/no-use-before-define": ["error", "nofunc"],
-    "@typescript-eslint/no-unused-vars": ["warn", { args: "none" }],
-    "@typescript-eslint/no-floating-promises": "error",
-    "@typescript-eslint/no-misused-promises": "error",
-    camelcase: 0,
-    "class-methods-use-this": 0,
-    "import/extensions": [2, "ignorePackages"],
-    "import/no-extraneous-dependencies": [
-      "error",
-      { devDependencies: ["**/*.test.ts"] },
-    ],
-    "import/no-unresolved": 0,
-    "import/prefer-default-export": 0,
-    "keyword-spacing": "error",
-    "max-classes-per-file": 0,
-    "max-len": 0,
-    "no-await-in-loop": 0,
-    "no-bitwise": 0,
-    "no-console": 0,
-    "no-restricted-syntax": 0,
-    "no-shadow": 0,
-    "no-continue": 0,
-    "no-underscore-dangle": 0,
-    "no-use-before-define": 0,
-    "no-useless-constructor": 0,
-    "no-return-await": 0,
-    "consistent-return": 0,
-    "no-else-return": 0,
-    "new-cap": ["error", { properties: false, capIsNew: false }],
-  },
-};
@@ -1,7 +0,0 @@
-{
-  "node_version": "20",
-  "graphs": {
-    "agent": "./src/graph.ts:graph"
-  },
-  "env": "../../.env"
-}
@@ -1,18 +0,0 @@
-{
-  "name": "@js-monorepo-example/agent",
-  "version": "0.0.1",
-  "type": "module",
-  "main": "src/graph.ts",
-  "scripts": {
-    "build": "tsc",
-    "clean": "rm -rf dist"
-  },
-  "dependencies": {
-    "@js-monorepo-example/shared": "*",
-    "@langchain/core": "^0.3.2",
-    "@langchain/langgraph": "^0.2.5"
-  },
-  "devDependencies": {
-    "typescript": "^5.3.3"
-  }
-}
@@ -1,47 +0,0 @@
-/**
- * Simple LangGraph.js example for monorepo testing
- */
-import { StateGraph } from "@langchain/langgraph";
-import { RunnableConfig } from "@langchain/core/runnables";
-import { StateAnnotation } from "./state.js";
-import { getGreeting } from "@js-monorepo-example/shared";
-
-/**
- * Simple node that uses the shared library
- */
-const callModel = async (
-  state: typeof StateAnnotation.State,
-  _config: RunnableConfig,
-): Promise<typeof StateAnnotation.Update> => {
-  // Use functions from the shared library
-  const greeting = getGreeting();
-
-  return {
-    messages: [
-      {
-        role: "assistant",
-        content: `${greeting}`,
-      },
-    ],
-  };
-};
-
-/**
- * Simple routing function
- */
-export const route = (
-  state: typeof StateAnnotation.State,
-): "__end__" | "callModel" => {
-  if (state.messages.length > 0) {
-    return "__end__";
-  }
-  return "callModel";
-};
-
-// Create the graph
-const builder = new StateGraph(StateAnnotation)
-  .addNode("callModel", callModel)
-  .addEdge("__start__", "callModel")
-  .addConditionalEdges("callModel", route);
-
-export const graph = builder.compile();
@@ -1,15 +0,0 @@
-import { BaseMessage, BaseMessageLike } from "@langchain/core/messages";
-import { Annotation, messagesStateReducer } from "@langchain/langgraph";
-
-/**
- * Simple state annotation for the agent
- */
-export const StateAnnotation = Annotation.Root({
-  /**
-   * Messages track the primary execution state of the agent.
-   */
-  messages: Annotation<BaseMessage[], BaseMessageLike[]>({
-    reducer: messagesStateReducer,
-    default: () => [],
-  }),
-});
@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}
@@ -1,14 +0,0 @@
-{
-  "name": "@js-monorepo-example/shared",
-  "version": "0.0.1",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "build": "tsc",
-    "clean": "rm -rf dist"
-  },
-  "devDependencies": {
-    "typescript": "^5.3.3"
-  }
-}
@@ -1,6 +0,0 @@
-/**
- * Simple utility functions for monorepo testing
- */
-export function getGreeting(): string {
-  return "Hello from shared library!";
-}
@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}
@@ -1,34 +0,0 @@
-{
-  "name": "js-monorepo-example",
-  "version": "0.0.1",
-  "packageManager": "yarn@1.22.22",
-  "description": "A simple monorepo example for LangGraph integration testing.",
-  "private": true,
-  "workspaces": [
-    "libs/*",
-    "apps/*"
-  ],
-  "type": "module",
-  "scripts": {
-    "build": "turbo build",
-    "clean": "turbo clean",
-    "test": "turbo test",
-    "format": "prettier --write .",
-    "lint": "eslint 'apps/**/*.ts' 'libs/**/*.ts'"
-  },
-  "devDependencies": {
-    "turbo": "^2.5.0",
-    "typescript": "^5.3.3",
-    "@tsconfig/recommended": "^1.0.7",
-    "@eslint/eslintrc": "^3.1.0",
-    "@eslint/js": "^9.9.1",
-    "eslint": "^8.41.0",
-    "eslint-config-prettier": "^8.8.0",
-    "eslint-plugin-import": "^2.27.5",
-    "eslint-plugin-no-instanceof": "^1.0.1",
-    "eslint-plugin-prettier": "^4.2.1",
-    "@typescript-eslint/eslint-plugin": "^5.59.8",
-    "@typescript-eslint/parser": "^5.59.8",
-    "prettier": "^3.3.3"
-  }
-}
@@ -1,16 +0,0 @@
-{
-  "extends": "@tsconfig/recommended",
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "node",
-    "allowSyntheticDefaultImports": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "declaration": true,
-    "outDir": "./dist"
-  },
-  "include": ["apps/**/*", "libs/**/*"],
-  "exclude": ["node_modules", "dist"]
-}
@@ -1,15 +0,0 @@
-{
-  "$schema": "https://turbo.build/schema.json",
-  "tasks": {
-    "build": {
-      "dependsOn": ["^build"],
-      "outputs": ["dist/**"]
-    },
-    "clean": {
-      "dependsOn": ["^clean"]
-    },
-    "test": {
-      "dependsOn": ["^test"]
-    }
-  }
-}
@@ -1 +1 @@
-__version__ = "0.4.2"
+__version__ = "0.4.0"
@@ -303,8 +303,6 @@ def _build(
    pull: bool,
    tag: str,
    passthrough: Sequence[str] = (),
-    install_command: Optional[str] = None,
-    build_command: Optional[str] = None,
 ):
    # pull latest images
    if pull:
@@ -324,38 +322,22 @@ def _build(
        "-t",
        tag,
    ]
-    # determine build context: use current directory for JS projects, config parent for Python
-    is_js_project = config_json.get("node_version") and not config_json.get(
-        "python_version"
-    )
-    # build/install commands only apply to JS projects for now
-    # without install/build command, JS projects will follow the old behavior
-    if is_js_project and (build_command or install_command):
-        build_context = str(pathlib.Path.cwd())
-    else:
-        build_context = str(config.parent)
-
    # apply config
    stdin, additional_contexts = langgraph_cli.config.config_to_docker(
-        config,
-        config_json,
-        base_image,
-        api_version,
-        install_command,
-        build_command,
-        build_context,
+        config, config_json, base_image, api_version
    )
    # add additional_contexts
    if additional_contexts:
        for k, v in additional_contexts.items():
            args.extend(["--build-context", f"{k}={v}"])
+    # run docker build
    runner.run(
        subp_exec(
            "docker",
            "build",
            *args,
            *passthrough,
-            build_context,
+            str(config.parent),
            input=stdin,
            verbose=True,
        )
@@ -384,14 +366,6 @@ def _build(
    "\n    --base-image langchain/langgraph-server:0.2  # Pin to a minor version (Python)",
 )
@OPT_API_VERSION
-@click.option(
-    "--install-command",
-    help="Custom install command to run from the build context root. If not provided, auto-detects based on package manager files.",
-)
-@click.option(
-    "--build-command",
-    help="Custom build command to run from the langgraph.json directory. If not provided, uses default build process.",
-)
@click.argument("docker_build_args", nargs=-1, type=click.UNPROCESSED)
@cli.command(
    help="📦 Build LangGraph API server Docker image.",
@@ -407,8 +381,6 @@ def build(
    api_version: Optional[str],
    pull: bool,
    tag: str,
-    install_command: Optional[str],
-    build_command: Optional[str],
 ):
    with Runner() as runner, Progress(message="Pulling...") as set:
        if shutil.which("docker") is None:
@@ -425,8 +397,6 @@ def build(
            pull,
            tag,
            docker_build_args,
-            install_command,
-            build_command,
        )


@@ -913,10 +913,10 @@ def _assemble_local_deps(config_path: pathlib.Path, config: Config) -> LocalDeps
                        "Rename the directory to use it as flat-layout package."
                    )
                check_reserved(resolved.name, local_dep)
-                container_path = f"/deps/outer-{resolved.name}/{resolved.name}"
+                container_path = f"/deps/__outer_{resolved.name}/{resolved.name}"
            else:
                # src layout
-                container_path = f"/deps/outer-{resolved.name}/src"
+                container_path = f"/deps/__outer_{resolved.name}/src"
                for file in files:
                    rfile = resolved / file
                    if (
@@ -1256,7 +1256,7 @@ def python_config_to_docker(
        else:
            pip_installer = "pip"
    if pip_installer == "uv":
-        install_cmd = "uv pip install --system --prerelease=allow"
+        install_cmd = "uv pip install --system"
    elif pip_installer == "pip":
        install_cmd = "pip install"
    else:
@@ -1286,7 +1286,7 @@ def python_config_to_docker(
    if local_deps.pip_reqs:
        pip_reqs_str = os.linesep.join(
            (
-                f"COPY --from=outer-{reqpath.name} requirements.txt {destpath}"
+                f"COPY --from=__outer_{reqpath.name} requirements.txt {destpath}"
                if reqpath.parent in local_deps.additional_contexts
                else f"ADD {reqpath.relative_to(config_path.parent)} {destpath}"
            )
@@ -1305,7 +1305,7 @@ def python_config_to_docker(
    faux_pkgs_str = f"{os.linesep}{os.linesep}".join(
        (
            f"""# -- Adding non-package dependency {fullpath.name} --
-COPY --from=outer-{fullpath.name} . {destpath}"""
+COPY --from=__outer_{fullpath.name} . {destpath}"""
            if fullpath in local_deps.additional_contexts
            else f"""# -- Adding non-package dependency {fullpath.name} --
 ADD {relpath} {destpath}"""
@@ -1320,7 +1320,7 @@ RUN set -ex && \\
                '[build-system]' \\
                'requires = ["setuptools>=61"]' \\
                'build-backend = "setuptools.build_meta"'; do \\
-        echo "$line" >> /deps/outer-{fullpath.name}/pyproject.toml; \\
+        echo "$line" >> /deps/__outer_{fullpath.name}/pyproject.toml; \\
    done
 # -- End of non-package dependency {fullpath.name} --"""
        for fullpath, (relpath, destpath) in local_deps.faux_pkgs.items()
@@ -1423,7 +1423,7 @@ ADD {relpath} /deps/{name}
        if p in local_deps.real_pkgs:
            name = local_deps.real_pkgs[p][1]
        elif p in local_deps.faux_pkgs:
-            name = f"outer-{p.name}"
+            name = f"__outer_{p.name}"
        else:
            raise RuntimeError(f"Unknown additional context: {p}")
        additional_contexts[name] = str(p)
@@ -1436,28 +1436,9 @@ def node_config_to_docker(
    config: Config,
    base_image: str,
    api_version: Optional[str] = None,
-    install_command: Optional[str] = None,
-    build_command: Optional[str] = None,
-    build_context: Optional[str] = None,
 ) -> tuple[str, dict[str, str]]:
-    # Calculate paths for monorepo support
-    if build_context:
-        relative_workdir = _calculate_relative_workdir(config_path, build_context)
-        container_name = pathlib.Path(build_context).name
-        if relative_workdir:
-            faux_path = f"/deps/{container_name}/{relative_workdir}"
-        else:
-            faux_path = f"/deps/{container_name}"
-    else:
-        # Backward compatibility: use the original behavior
-        faux_path = f"/deps/{config_path.parent.name}"
-
-    # Use custom install command or auto-detect
-    if install_command:
-        install_cmd = install_command
-    else:
-        install_cmd = _get_node_pm_install_cmd(config_path, config)
-
+    faux_path = f"/deps/{config_path.parent.name}"
+    install_cmd = _get_node_pm_install_cmd(config_path, config)
    image_str = docker_tag(config, base_image, api_version)

    env_vars: list[str] = []
@@ -1484,35 +1465,20 @@ def node_config_to_docker(

    env_vars.append(f"ENV LANGSERVE_GRAPHS='{json.dumps(config['graphs'])}'")

-    # For monorepo support, we need to handle install and build commands differently
-    if build_context:
-        # Monorepo case: install from root, build from config directory
-        container_root = f"/deps/{pathlib.Path(build_context).name}"
-        install_step = f"RUN cd {container_root} && {install_cmd}"
-
-        if build_command:
-            build_step = f"RUN cd {faux_path} && {build_command}"
-        else:
-            build_step = 'RUN (test ! -f /api/langgraph_api/js/build.mts && echo "Prebuild script not found, skipping") || tsx /api/langgraph_api/js/build.mts'
-    else:
-        # Original behavior: everything happens in the same directory
-        install_step = f"RUN cd {faux_path} && {install_cmd}"
-        build_step = 'RUN (test ! -f /api/langgraph_api/js/build.mts && echo "Prebuild script not found, skipping") || tsx /api/langgraph_api/js/build.mts'
-
    docker_file_contents = [
        f"FROM {image_str}",
        "",
        os.linesep.join(config["dockerfile_lines"]),
        "",
-        f"ADD . {faux_path if not build_context else container_root}",
+        f"ADD . {faux_path}",
        "",
-        install_step,
+        f"RUN cd {faux_path} && {install_cmd}",
        "",
        os.linesep.join(env_vars),
        "",
        f"WORKDIR {faux_path}",
        "",
-        build_step,
+        'RUN (test ! -f /api/langgraph_api/js/build.mts && echo "Prebuild script not found, skipping") || tsx /api/langgraph_api/js/build.mts',
    ]

    return os.linesep.join(docker_file_contents), {}
@@ -1560,42 +1526,16 @@ def docker_tag(
    return f"{base_image}:{full_tag}"


-def _calculate_relative_workdir(config_path: pathlib.Path, build_context: str) -> str:
-    """Calculate the relative path from build context to langgraph.json directory."""
-    config_dir = config_path.parent.resolve()
-    build_context_path = pathlib.Path(build_context).resolve()
-
-    try:
-        relative_path = config_dir.relative_to(build_context_path)
-        return str(relative_path) if str(relative_path) != "." else ""
-    except ValueError as _:
-        raise ValueError(
-            f"Configuration file {config_path} is not under the build context {build_context}. "
-            f"Please run the command from a directory that contains your langgraph.json file, "
-        ) from None
-
-
 def config_to_docker(
    config_path: pathlib.Path,
    config: Config,
    base_image: Optional[str] = None,
    api_version: Optional[str] = None,
-    install_command: Optional[str] = None,
-    build_command: Optional[str] = None,
-    build_context: Optional[str] = None,
 ) -> tuple[str, dict[str, str]]:
    base_image = base_image or default_base_image(config)

    if config.get("node_version") and not config.get("python_version"):
-        return node_config_to_docker(
-            config_path,
-            config,
-            base_image,
-            api_version,
-            install_command,
-            build_command,
-            build_context,
-        )
+        return node_config_to_docker(config_path, config, base_image, api_version)

    return python_config_to_docker(config_path, config, base_image, api_version)

@@ -1,7 +0,0 @@
-{
-  "dependencies": [".", "../../libs/shared", "../../libs/common"],
-  "graphs": {
-    "agent": "./src/agent/graph.py:graph"
-  },
-  "env": ".env"
-}
@@ -1,19 +0,0 @@
-[project]
-name = "agent"
-version = "0.0.1"
-description = "Agent for the Python monorepo"
-authors = [
-    { name = "Developer", email = "dev@example.com" },
-]
-license = { text = "MIT" }
-requires-python = ">=3.11,<4.0"
-
-[build-system]
-requires = ["setuptools>=73.0.0", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[tool.setuptools]
-packages = ["agent"]
-
-[tool.setuptools.package-dir]
-"agent" = "src/agent"
@@ -1 +0,0 @@
-"""Agent package."""
@@ -1,40 +0,0 @@
-"""Simple LangGraph agent for monorepo testing."""
-
-from common import get_common_prefix
-from langchain_core.messages import AIMessage
-from langgraph.graph import END, START, StateGraph
-from shared import get_dummy_message
-
-from agent.state import State
-
-
-def call_model(state: State) -> dict:
-    """Simple node that uses the shared libraries."""
-    # Use functions from both shared packages
-    dummy_message = get_dummy_message()
-    prefix = get_common_prefix()
-
-    message = AIMessage(content=f"{prefix} Agent says: {dummy_message}")
-
-    return {"messages": [message]}
-
-
-def should_continue(state: State):
-    """Conditional edge - end after first message."""
-    messages = state["messages"]
-    if len(messages) > 0:
-        return END
-    return "call_model"
-
-
-# Build the graph
-workflow = StateGraph(State)
-
-# Add the node
-workflow.add_node("call_model", call_model)
-
-# Add edges
-workflow.add_edge(START, "call_model")
-workflow.add_conditional_edges("call_model", should_continue)
-
-graph = workflow.compile()
@@ -1,13 +0,0 @@
-"""State definition for the agent."""
-
-from collections.abc import Sequence
-from typing import Annotated, TypedDict
-
-from langchain_core.messages import BaseMessage
-from langgraph.graph.message import add_messages
-
-
-class State(TypedDict):
-    """The state of the agent."""
-
-    messages: Annotated[Sequence[BaseMessage], add_messages]
@@ -1,5 +0,0 @@
-"""Common helper functions package."""
-
-from .helpers import get_common_prefix
-
-__all__ = ["get_common_prefix"]
@@ -1,6 +0,0 @@
-"""Common helper functions."""
-
-
-def get_common_prefix() -> str:
-    """Get a common prefix for messages."""
-    return "[COMMON]"
@@ -1,20 +0,0 @@
-[project]
-name = "shared"
-version = "0.0.1"
-description = "Shared utilities for the Python monorepo"
-authors = [
-    { name = "Developer", email = "dev@example.com" },
-]
-license = { text = "MIT" }
-requires-python = ">=3.11,<4.0"
-dependencies = []
-
-[build-system]
-requires = ["setuptools>=73.0.0", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[tool.setuptools]
-packages = ["shared"]
-
-[tool.setuptools.package-dir]
-"shared" = "src/shared"
@@ -1,5 +0,0 @@
-"""Shared utilities package."""
-
-from .utils import get_dummy_message
-
-__all__ = ["get_dummy_message"]
@@ -1,6 +0,0 @@
-"""Shared utility functions."""
-
-
-def get_dummy_message() -> str:
-    """Get a dummy message for testing."""
-    return "Hello from shared library!"
@@ -1,46 +0,0 @@
-[project]
-name = "python-monorepo-example"
-version = "0.0.1"
-description = "A Python monorepo example with LangGraph agents and shared packages"
-authors = [
-    { name = "Developer", email = "dev@example.com" },
-]
-license = { text = "MIT" }
-requires-python = ">=3.11,<4.0"
-dependencies = [
-    "langgraph>=0.6.0,<0.7.0",
-    "langchain-core>=0.2.14",
-]
-
-[tool.uv.workspace]
-members = ["apps/*", "libs/shared"]
-
-[tool.uv.sources]
-shared = { workspace = true }
-
-[project.optional-dependencies]
-dev = ["mypy>=1.11.1", "ruff>=0.6.1"]
-
-[build-system]
-requires = ["setuptools>=73.0.0", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[tool.ruff]
-lint.select = [
-    "E",    # pycodestyle
-    "F",    # pyflakes
-    "I",    # isort
-    "D",    # pydocstyle
-    "UP",
-]
-lint.ignore = [
-    "D100",  # Missing docstring in public module
-    "D101",  # Missing docstring in public class
-    "D102",  # Missing docstring in public method
-    "D103",  # Missing docstring in public function
-    "D104",  # Missing docstring in public package
-    "D105",  # Missing docstring in magic method
-]
-
-[tool.ruff.lint.pydocstyle]
-convention = "google"
@@ -15,7 +15,7 @@ from langgraph_cli.docker import DEFAULT_POSTGRES_URI, DockerCapabilities, Versi
 from langgraph_cli.util import clean_empty_lines

 FORMATTED_CLEANUP_LINES = _get_pip_cleanup_lines(
-    install_cmd="uv pip install --system --prerelease=allow",
+    install_cmd="uv pip install --system",
    to_uninstall=("pip", "setuptools", "wheel"),
    pip_installer="uv",
 )
@@ -149,7 +149,7 @@ services:
                COPY --from=cli_1 . /deps/cli_1
                # -- End of local package ../../.. --
                # -- Installing all local dependencies --
-                RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --prerelease=allow --no-cache-dir -c /api/constraints.txt -e /deps/*
+                RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
                # -- End of local dependencies install --
                ENV LANGSERVE_GRAPHS='{{"agent": "agent.py:graph"}}'
 {textwrap.indent(textwrap.dedent(FORMATTED_CLEANUP_LINES), "                ")}
@@ -570,7 +570,7 @@ def test_build_generate_proper_build_context():
                catch_exceptions=True,
            )

-        build_context_pattern = re.compile(r"--build-context\s+([\w-]+)=([^\s]+)")
+        build_context_pattern = re.compile(r"--build-context\s+(\w+)=([^\s]+)")

        build_contexts = re.findall(build_context_pattern, result.output)
        assert len(build_contexts) == 2, (
@@ -20,7 +20,7 @@ from langgraph_cli.config import (
 from langgraph_cli.util import clean_empty_lines

 FORMATTED_CLEANUP_LINES = _get_pip_cleanup_lines(
-    install_cmd="uv pip install --system --prerelease=allow",
+    install_cmd="uv pip install --system",
    to_uninstall=("pip", "setuptools", "wheel"),
    pip_installer="uv",
 )
@@ -421,14 +421,14 @@ def test_config_to_docker_simple():
    expected_docker_stdin = f"""\
 FROM langchain/langgraph-api:3.11
 # -- Installing local requirements --
-COPY --from=outer-requirements.txt requirements.txt /deps/outer-graphs_reqs_a/graphs_reqs_a/requirements.txt
-RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --prerelease=allow --no-cache-dir -c /api/constraints.txt -r /deps/outer-graphs_reqs_a/graphs_reqs_a/requirements.txt
+COPY --from=__outer_requirements.txt requirements.txt /deps/__outer_graphs_reqs_a/graphs_reqs_a/requirements.txt
+RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -r /deps/__outer_graphs_reqs_a/graphs_reqs_a/requirements.txt
 # -- End of local requirements install --
 # -- Adding local package ../../examples --
 COPY --from=examples . /deps/examples
 # -- End of local package ../../examples --
 # -- Adding non-package dependency unit_tests --
-ADD . /deps/outer-unit_tests/unit_tests
+ADD . /deps/__outer_unit_tests/unit_tests
 RUN set -ex && \\
    for line in '[project]' \\
                'name = "unit_tests"' \\
@@ -438,11 +438,11 @@ RUN set -ex && \\
                '[build-system]' \\
                'requires = ["setuptools>=61"]' \\
                'build-backend = "setuptools.build_meta"'; do \\
-        echo "$line" >> /deps/outer-unit_tests/pyproject.toml; \\
+        echo "$line" >> /deps/__outer_unit_tests/pyproject.toml; \\
    done
 # -- End of non-package dependency unit_tests --
 # -- Adding non-package dependency graphs_reqs_a --
-COPY --from=outer-graphs_reqs_a . /deps/outer-graphs_reqs_a/graphs_reqs_a
+COPY --from=__outer_graphs_reqs_a . /deps/__outer_graphs_reqs_a/graphs_reqs_a
 RUN set -ex && \\
    for line in '[project]' \\
                'name = "graphs_reqs_a"' \\
@@ -452,21 +452,21 @@ RUN set -ex && \\
                '[build-system]' \\
                'requires = ["setuptools>=61"]' \\
                'build-backend = "setuptools.build_meta"'; do \\
-        echo "$line" >> /deps/outer-graphs_reqs_a/pyproject.toml; \\
+        echo "$line" >> /deps/__outer_graphs_reqs_a/pyproject.toml; \\
    done
 # -- End of non-package dependency graphs_reqs_a --
 # -- Installing all local dependencies --
-RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --prerelease=allow --no-cache-dir -c /api/constraints.txt -e /deps/*
+RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
 # -- End of local dependencies install --
 ENV LANGGRAPH_HTTP='{{"app": "/deps/examples/my_app.py:app"}}'
-ENV LANGSERVE_GRAPHS='{{"agent": "/deps/outer-unit_tests/unit_tests/agent.py:graph"}}'
+ENV LANGSERVE_GRAPHS='{{"agent": "/deps/__outer_unit_tests/unit_tests/agent.py:graph"}}'
 {FORMATTED_CLEANUP_LINES}
-WORKDIR /deps/outer-unit_tests/unit_tests\
+WORKDIR /deps/__outer_unit_tests/unit_tests\
 """
    assert clean_empty_lines(actual_docker_stdin) == expected_docker_stdin

    assert additional_contexts == {
-        "outer-graphs_reqs_a": str(
+        "__outer_graphs_reqs_a": str(
            (pathlib.Path(__file__).parent / "../../examples/graphs_reqs_a").resolve()
        ),
        "examples": str((pathlib.Path(__file__).parent / "../../examples").resolve()),
@@ -484,7 +484,7 @@ def test_config_to_docker_outside_path():
        """\
 FROM langchain/langgraph-api:3.11
 # -- Adding non-package dependency unit_tests --
-ADD . /deps/outer-unit_tests/unit_tests
+ADD . /deps/__outer_unit_tests/unit_tests
 RUN set -ex && \\
    for line in '[project]' \\
                'name = "unit_tests"' \\
@@ -494,11 +494,11 @@ RUN set -ex && \\
                '[build-system]' \\
                'requires = ["setuptools>=61"]' \\
                'build-backend = "setuptools.build_meta"'; do \\
-        echo "$line" >> /deps/outer-unit_tests/pyproject.toml; \\
+        echo "$line" >> /deps/__outer_unit_tests/pyproject.toml; \\
    done
 # -- End of non-package dependency unit_tests --
 # -- Adding non-package dependency tests --
-COPY --from=outer-tests . /deps/outer-tests/tests
+COPY --from=__outer_tests . /deps/__outer_tests/tests
 RUN set -ex && \\
    for line in '[project]' \\
                'name = "tests"' \\
@@ -508,22 +508,22 @@ RUN set -ex && \\
                '[build-system]' \\
                'requires = ["setuptools>=61"]' \\
                'build-backend = "setuptools.build_meta"'; do \\
-        echo "$line" >> /deps/outer-tests/pyproject.toml; \\
+        echo "$line" >> /deps/__outer_tests/pyproject.toml; \\
    done
 # -- End of non-package dependency tests --
 # -- Installing all local dependencies --
-RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --prerelease=allow --no-cache-dir -c /api/constraints.txt -e /deps/*
+RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
 # -- End of local dependencies install --
-ENV LANGSERVE_GRAPHS='{"agent": "/deps/outer-unit_tests/unit_tests/agent.py:graph"}'
+ENV LANGSERVE_GRAPHS='{"agent": "/deps/__outer_unit_tests/unit_tests/agent.py:graph"}'
 """
        + FORMATTED_CLEANUP_LINES
        + """
-WORKDIR /deps/outer-unit_tests/unit_tests\
+WORKDIR /deps/__outer_unit_tests/unit_tests\
 """
    )
    assert clean_empty_lines(actual_docker_stdin) == expected_docker_stdin
    assert additional_contexts == {
-        "outer-tests": str(pathlib.Path(__file__).parent.parent.absolute()),
+        "__outer_tests": str(pathlib.Path(__file__).parent.parent.absolute()),
    }


@@ -545,7 +545,7 @@ def test_config_to_docker_pipconfig():
 FROM langchain/langgraph-api:3.11
 ADD pipconfig.txt /pipconfig.txt
 # -- Adding non-package dependency unit_tests --
-ADD . /deps/outer-unit_tests/unit_tests
+ADD . /deps/__outer_unit_tests/unit_tests
 RUN set -ex && \\
    for line in '[project]' \\
                'name = "unit_tests"' \\
@@ -555,17 +555,17 @@ RUN set -ex && \\
                '[build-system]' \\
                'requires = ["setuptools>=61"]' \\
                'build-backend = "setuptools.build_meta"'; do \\
-        echo "$line" >> /deps/outer-unit_tests/pyproject.toml; \\
+        echo "$line" >> /deps/__outer_unit_tests/pyproject.toml; \\
    done
 # -- End of non-package dependency unit_tests --
 # -- Installing all local dependencies --
-RUN PIP_CONFIG_FILE=/pipconfig.txt PYTHONDONTWRITEBYTECODE=1 uv pip install --system --prerelease=allow --no-cache-dir -c /api/constraints.txt -e /deps/*
+RUN PIP_CONFIG_FILE=/pipconfig.txt PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
 # -- End of local dependencies install --
-ENV LANGSERVE_GRAPHS='{"agent": "/deps/outer-unit_tests/unit_tests/agent.py:graph"}'
+ENV LANGSERVE_GRAPHS='{"agent": "/deps/__outer_unit_tests/unit_tests/agent.py:graph"}'
 """
        + FORMATTED_CLEANUP_LINES
        + """
-WORKDIR /deps/outer-unit_tests/unit_tests\
+WORKDIR /deps/__outer_unit_tests/unit_tests\
 """
    )
    assert clean_empty_lines(actual_docker_stdin) == expected_docker_stdin
@@ -607,7 +607,7 @@ def test_config_to_docker_local_deps():
    expected_docker_stdin = f"""\
 FROM langchain/langgraph-api-custom:3.11
 # -- Adding non-package dependency graphs --
-ADD ./graphs /deps/outer-graphs/src
+ADD ./graphs /deps/__outer_graphs/src
 RUN set -ex && \\
    for line in '[project]' \\
                'name = "graphs"' \\
@@ -617,13 +617,13 @@ RUN set -ex && \\
                '[build-system]' \\
                'requires = ["setuptools>=61"]' \\
                'build-backend = "setuptools.build_meta"'; do \\
-        echo "$line" >> /deps/outer-graphs/pyproject.toml; \\
+        echo "$line" >> /deps/__outer_graphs/pyproject.toml; \\
    done
 # -- End of non-package dependency graphs --
 # -- Installing all local dependencies --
-RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --prerelease=allow --no-cache-dir -c /api/constraints.txt -e /deps/*
+RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
 # -- End of local dependencies install --
-ENV LANGSERVE_GRAPHS='{{"agent": "/deps/outer-graphs/src/agent.py:graph"}}'
+ENV LANGSERVE_GRAPHS='{{"agent": "/deps/__outer_graphs/src/agent.py:graph"}}'
 {FORMATTED_CLEANUP_LINES}\
 """
    assert clean_empty_lines(actual_docker_stdin) == expected_docker_stdin
@@ -657,7 +657,7 @@ dependencies = ["langchain"]"""
 ADD . /deps/unit_tests
 # -- End of local package . --
 # -- Installing all local dependencies --
-RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --prerelease=allow --no-cache-dir -c /api/constraints.txt -e /deps/*
+RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
 # -- End of local dependencies install --
 ENV LANGSERVE_GRAPHS='{"agent": "/deps/unit_tests/graphs/agent.py:graph"}'
 """
@@ -689,9 +689,9 @@ def test_config_to_docker_end_to_end():
 ARG meow
 ARG foo
 ADD pipconfig.txt /pipconfig.txt
-RUN PIP_CONFIG_FILE=/pipconfig.txt PYTHONDONTWRITEBYTECODE=1 uv pip install --system --prerelease=allow --no-cache-dir -c /api/constraints.txt langchain langchain_openai
+RUN PIP_CONFIG_FILE=/pipconfig.txt PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt langchain langchain_openai
 # -- Adding non-package dependency graphs --
-ADD ./graphs/ /deps/outer-graphs/src
+ADD ./graphs/ /deps/__outer_graphs/src
 RUN set -ex && \\
    for line in '[project]' \\
                'name = "graphs"' \\
@@ -701,13 +701,13 @@ RUN set -ex && \\
                '[build-system]' \\
                'requires = ["setuptools>=61"]' \\
                'build-backend = "setuptools.build_meta"'; do \\
-        echo "$line" >> /deps/outer-graphs/pyproject.toml; \\
+        echo "$line" >> /deps/__outer_graphs/pyproject.toml; \\
    done
 # -- End of non-package dependency graphs --
 # -- Installing all local dependencies --
-RUN PIP_CONFIG_FILE=/pipconfig.txt PYTHONDONTWRITEBYTECODE=1 uv pip install --system --prerelease=allow --no-cache-dir -c /api/constraints.txt -e /deps/*
+RUN PIP_CONFIG_FILE=/pipconfig.txt PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
 # -- End of local dependencies install --
-ENV LANGSERVE_GRAPHS='{{"agent": "/deps/outer-graphs/src/agent.py:graph"}}'
+ENV LANGSERVE_GRAPHS='{{"agent": "/deps/__outer_graphs/src/agent.py:graph"}}'
 {FORMATTED_CLEANUP_LINES}"""
    assert clean_empty_lines(actual_docker_stdin) == expected_docker_stdin
    assert additional_contexts == {}
@@ -797,7 +797,7 @@ def test_config_to_docker_gen_ui_python():
    expected_docker_stdin = f"""FROM langchain/langgraph-api:3.11
 RUN /storage/install-node.sh
 # -- Adding non-package dependency unit_tests --
-ADD . /deps/outer-unit_tests/unit_tests
+ADD . /deps/__outer_unit_tests/unit_tests
 RUN set -ex && \\
    for line in '[project]' \\
                'name = "unit_tests"' \\
@@ -807,21 +807,21 @@ RUN set -ex && \\
                '[build-system]' \\
                'requires = ["setuptools>=61"]' \\
                'build-backend = "setuptools.build_meta"'; do \\
-        echo "$line" >> /deps/outer-unit_tests/pyproject.toml; \\
+        echo "$line" >> /deps/__outer_unit_tests/pyproject.toml; \\
    done
 # -- End of non-package dependency unit_tests --
 # -- Installing all local dependencies --
-RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --prerelease=allow --no-cache-dir -c /api/constraints.txt -e /deps/*
+RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
 # -- End of local dependencies install --
 ENV LANGGRAPH_UI='{{"agent": "./graphs/agent.ui.jsx"}}'
 ENV LANGGRAPH_UI_CONFIG='{{"shared": ["nuqs"]}}'
-ENV LANGSERVE_GRAPHS='{{"agent": "/deps/outer-unit_tests/unit_tests/agent.py:graph"}}'
+ENV LANGSERVE_GRAPHS='{{"agent": "/deps/__outer_unit_tests/unit_tests/agent.py:graph"}}'
 # -- Installing JS dependencies --
 ENV NODE_VERSION=20
-RUN cd /deps/outer-unit_tests/unit_tests && npm i && tsx /api/langgraph_api/js/build.mts
+RUN cd /deps/__outer_unit_tests/unit_tests && npm i && tsx /api/langgraph_api/js/build.mts
 # -- End of JS dependencies install --
 {FORMATTED_CLEANUP_LINES}
-WORKDIR /deps/outer-unit_tests/unit_tests"""
+WORKDIR /deps/__outer_unit_tests/unit_tests"""

    assert clean_empty_lines(actual_docker_stdin) == expected_docker_stdin
    assert additional_contexts == {}
@@ -843,7 +843,7 @@ def test_config_to_docker_multiplatform():
    expected_docker_stdin = f"""FROM langchain/langgraph-api:3.11
 RUN /storage/install-node.sh
 # -- Adding non-package dependency unit_tests --
-ADD . /deps/outer-unit_tests/unit_tests
+ADD . /deps/__outer_unit_tests/unit_tests
 RUN set -ex && \\
    for line in '[project]' \\
                'name = "unit_tests"' \\
@@ -853,19 +853,19 @@ RUN set -ex && \\
                '[build-system]' \\
                'requires = ["setuptools>=61"]' \\
                'build-backend = "setuptools.build_meta"'; do \\
-        echo "$line" >> /deps/outer-unit_tests/pyproject.toml; \\
+        echo "$line" >> /deps/__outer_unit_tests/pyproject.toml; \\
    done
 # -- End of non-package dependency unit_tests --
 # -- Installing all local dependencies --
-RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --prerelease=allow --no-cache-dir -c /api/constraints.txt -e /deps/*
+RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
 # -- End of local dependencies install --
-ENV LANGSERVE_GRAPHS='{{"python": "/deps/outer-unit_tests/unit_tests/multiplatform/python.py:graph", "js": "/deps/outer-unit_tests/unit_tests/multiplatform/js.mts:graph"}}'
+ENV LANGSERVE_GRAPHS='{{"python": "/deps/__outer_unit_tests/unit_tests/multiplatform/python.py:graph", "js": "/deps/__outer_unit_tests/unit_tests/multiplatform/js.mts:graph"}}'
 # -- Installing JS dependencies --
 ENV NODE_VERSION=22
-RUN cd /deps/outer-unit_tests/unit_tests && npm i && tsx /api/langgraph_api/js/build.mts
+RUN cd /deps/__outer_unit_tests/unit_tests && npm i && tsx /api/langgraph_api/js/build.mts
 # -- End of JS dependencies install --
 {FORMATTED_CLEANUP_LINES}
-WORKDIR /deps/outer-unit_tests/unit_tests"""
+WORKDIR /deps/__outer_unit_tests/unit_tests"""

    assert clean_empty_lines(actual_docker_stdin) == expected_docker_stdin
    assert additional_contexts == {}
@@ -887,7 +887,7 @@ def test_config_to_docker_pip_installer():
    docker_auto, _ = config_to_docker(
        PATH_TO_CONFIG, config_auto, "langchain/langgraph-api:0.2.47"
    )
-    assert "uv pip install --system --prerelease=allow" in docker_auto
+    assert "uv pip install --system" in docker_auto
    assert "rm /usr/bin/uv /usr/bin/uvx" in docker_auto

    # Test explicit pip setting
@@ -895,7 +895,7 @@ def test_config_to_docker_pip_installer():
    docker_pip, _ = config_to_docker(
        PATH_TO_CONFIG, config_pip, "langchain/langgraph-api:0.2.47"
    )
-    assert "uv pip install --system --prerelease=allow" not in docker_pip
+    assert "uv pip install --system" not in docker_pip
    assert "pip install" in docker_pip
    assert "rm /usr/bin/uv" not in docker_pip

@@ -904,7 +904,7 @@ def test_config_to_docker_pip_installer():
    docker_uv, _ = config_to_docker(
        PATH_TO_CONFIG, config_uv, "langchain/langgraph-api:0.2.47"
    )
-    assert "uv pip install --system --prerelease=allow" in docker_uv
+    assert "uv pip install --system" in docker_uv
    assert "rm /usr/bin/uv /usr/bin/uvx" in docker_uv

    # Test auto behavior with older image (should use pip)
@@ -914,7 +914,7 @@ def test_config_to_docker_pip_installer():
    docker_auto_old, _ = config_to_docker(
        PATH_TO_CONFIG, config_auto_old, "langchain/langgraph-api:0.2.46"
    )
-    assert "uv pip install --system --prerelease=allow" not in docker_auto_old
+    assert "uv pip install --system" not in docker_auto_old
    assert "pip install" in docker_auto_old
    assert "rm /usr/bin/uv" not in docker_auto_old

@@ -923,7 +923,7 @@ def test_config_to_docker_pip_installer():
    docker_default, _ = config_to_docker(
        PATH_TO_CONFIG, config_default, "langchain/langgraph-api:0.2.47"
    )
-    assert "uv pip install --system --prerelease=allow" in docker_default
+    assert "uv pip install --system" in docker_default


 def test_config_retain_build_tools():
@@ -984,7 +984,7 @@ def test_config_to_compose_simple_config():
            dockerfile_inline: |
                FROM langchain/langgraph-api:3.11
                # -- Adding non-package dependency unit_tests --
-                ADD . /deps/outer-unit_tests/unit_tests
+                ADD . /deps/__outer_unit_tests/unit_tests
                RUN set -ex && \\
                    for line in '[project]' \\
                                'name = "unit_tests"' \\
@@ -994,15 +994,15 @@ def test_config_to_compose_simple_config():
                                '[build-system]' \\
                                'requires = ["setuptools>=61"]' \\
                                'build-backend = "setuptools.build_meta"'; do \\
-                        echo "$line" >> /deps/outer-unit_tests/pyproject.toml; \\
+                        echo "$line" >> /deps/__outer_unit_tests/pyproject.toml; \\
                    done
                # -- End of non-package dependency unit_tests --
                # -- Installing all local dependencies --
-                RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --prerelease=allow --no-cache-dir -c /api/constraints.txt -e /deps/*
+                RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
                # -- End of local dependencies install --
-                ENV LANGSERVE_GRAPHS='{{"agent": "/deps/outer-unit_tests/unit_tests/agent.py:graph"}}'
+                ENV LANGSERVE_GRAPHS='{{"agent": "/deps/__outer_unit_tests/unit_tests/agent.py:graph"}}'
 {textwrap.indent(textwrap.dedent(FORMATTED_CLEANUP_LINES), "                ")}
-                WORKDIR /deps/outer-unit_tests/unit_tests
+                WORKDIR /deps/__outer_unit_tests/unit_tests
        """
    actual_compose_stdin = config_to_compose(
        PATH_TO_CONFIG,
@@ -1025,7 +1025,7 @@ def test_config_to_compose_env_vars():
            dockerfile_inline: |
                FROM langchain/langgraph-api-custom:3.11
                # -- Adding non-package dependency unit_tests --
-                ADD . /deps/outer-unit_tests/unit_tests
+                ADD . /deps/__outer_unit_tests/unit_tests
                RUN set -ex && \\
                    for line in '[project]' \\
                                'name = "unit_tests"' \\
@@ -1035,15 +1035,15 @@ def test_config_to_compose_env_vars():
                                '[build-system]' \\
                                'requires = ["setuptools>=61"]' \\
                                'build-backend = "setuptools.build_meta"'; do \\
-                        echo "$line" >> /deps/outer-unit_tests/pyproject.toml; \\
+                        echo "$line" >> /deps/__outer_unit_tests/pyproject.toml; \\
                    done
                # -- End of non-package dependency unit_tests --
                # -- Installing all local dependencies --
-                RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --prerelease=allow --no-cache-dir -c /api/constraints.txt -e /deps/*
+                RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
                # -- End of local dependencies install --
-                ENV LANGSERVE_GRAPHS='{{"agent": "/deps/outer-unit_tests/unit_tests/agent.py:graph"}}'
+                ENV LANGSERVE_GRAPHS='{{"agent": "/deps/__outer_unit_tests/unit_tests/agent.py:graph"}}'
 {textwrap.indent(textwrap.dedent(FORMATTED_CLEANUP_LINES), "                ")}
-                WORKDIR /deps/outer-unit_tests/unit_tests
+                WORKDIR /deps/__outer_unit_tests/unit_tests
        """
    openai_api_key = "key"
    actual_compose_stdin = config_to_compose(
@@ -1070,7 +1070,7 @@ def test_config_to_compose_env_file():
            dockerfile_inline: |
                FROM langchain/langgraph-api:3.11
                # -- Adding non-package dependency unit_tests --
-                ADD . /deps/outer-unit_tests/unit_tests
+                ADD . /deps/__outer_unit_tests/unit_tests
                RUN set -ex && \\
                    for line in '[project]' \\
                                'name = "unit_tests"' \\
@@ -1080,15 +1080,15 @@ def test_config_to_compose_env_file():
                                '[build-system]' \\
                                'requires = ["setuptools>=61"]' \\
                                'build-backend = "setuptools.build_meta"'; do \\
-                        echo "$line" >> /deps/outer-unit_tests/pyproject.toml; \\
+                        echo "$line" >> /deps/__outer_unit_tests/pyproject.toml; \\
                    done
                # -- End of non-package dependency unit_tests --
                # -- Installing all local dependencies --
-                RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --prerelease=allow --no-cache-dir -c /api/constraints.txt -e /deps/*
+                RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
                # -- End of local dependencies install --
-                ENV LANGSERVE_GRAPHS='{{"agent": "/deps/outer-unit_tests/unit_tests/agent.py:graph"}}'
+                ENV LANGSERVE_GRAPHS='{{"agent": "/deps/__outer_unit_tests/unit_tests/agent.py:graph"}}'
 {textwrap.indent(textwrap.dedent(FORMATTED_CLEANUP_LINES), "                ")}
-                WORKDIR /deps/outer-unit_tests/unit_tests
+                WORKDIR /deps/__outer_unit_tests/unit_tests
        """
    actual_compose_stdin = config_to_compose(
        PATH_TO_CONFIG,
@@ -1108,7 +1108,7 @@ def test_config_to_compose_watch():
            dockerfile_inline: |
                FROM langchain/langgraph-api:3.11
                # -- Adding non-package dependency unit_tests --
-                ADD . /deps/outer-unit_tests/unit_tests
+                ADD . /deps/__outer_unit_tests/unit_tests
                RUN set -ex && \\
                    for line in '[project]' \\
                                'name = "unit_tests"' \\
@@ -1118,15 +1118,15 @@ def test_config_to_compose_watch():
                                '[build-system]' \\
                                'requires = ["setuptools>=61"]' \\
                                'build-backend = "setuptools.build_meta"'; do \\
-                        echo "$line" >> /deps/outer-unit_tests/pyproject.toml; \\
+                        echo "$line" >> /deps/__outer_unit_tests/pyproject.toml; \\
                    done
                # -- End of non-package dependency unit_tests --
                # -- Installing all local dependencies --
-                RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --prerelease=allow --no-cache-dir -c /api/constraints.txt -e /deps/*
+                RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
                # -- End of local dependencies install --
-                ENV LANGSERVE_GRAPHS='{{"agent": "/deps/outer-unit_tests/unit_tests/agent.py:graph"}}'
+                ENV LANGSERVE_GRAPHS='{{"agent": "/deps/__outer_unit_tests/unit_tests/agent.py:graph"}}'
 {textwrap.indent(textwrap.dedent(FORMATTED_CLEANUP_LINES), "                ")}
-                WORKDIR /deps/outer-unit_tests/unit_tests
+                WORKDIR /deps/__outer_unit_tests/unit_tests
        
        develop:
            watch:
@@ -1155,7 +1155,7 @@ def test_config_to_compose_end_to_end():
            dockerfile_inline: |
                FROM langchain/langgraph-api:3.11
                # -- Adding non-package dependency unit_tests --
-                ADD . /deps/outer-unit_tests/unit_tests
+                ADD . /deps/__outer_unit_tests/unit_tests
                RUN set -ex && \\
                    for line in '[project]' \\
                                'name = "unit_tests"' \\
@@ -1165,15 +1165,15 @@ def test_config_to_compose_end_to_end():
                                '[build-system]' \\
                                'requires = ["setuptools>=61"]' \\
                                'build-backend = "setuptools.build_meta"'; do \\
-                        echo "$line" >> /deps/outer-unit_tests/pyproject.toml; \\
+                        echo "$line" >> /deps/__outer_unit_tests/pyproject.toml; \\
                    done
                # -- End of non-package dependency unit_tests --
                # -- Installing all local dependencies --
-                RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --prerelease=allow --no-cache-dir -c /api/constraints.txt -e /deps/*
+                RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
                # -- End of local dependencies install --
-                ENV LANGSERVE_GRAPHS='{{"agent": "/deps/outer-unit_tests/unit_tests/agent.py:graph"}}'
+                ENV LANGSERVE_GRAPHS='{{"agent": "/deps/__outer_unit_tests/unit_tests/agent.py:graph"}}'
 {textwrap.indent(textwrap.dedent(FORMATTED_CLEANUP_LINES), "                ")}
-                WORKDIR /deps/outer-unit_tests/unit_tests
+                WORKDIR /deps/__outer_unit_tests/unit_tests
        
        develop:
            watch:
@@ -5,9 +5,7 @@
      "Bash(python:*)",
      "Bash(grep:*)",
      "Bash(sed:*)",
-      "Bash(awk:*)",
-      "Bash(uv run mypy:*)",
-      "Bash(uv run:*)"
+      "Bash(awk:*)"
    ],
    "deny": []
  }
@@ -71,7 +71,7 @@ While LangGraph can be used standalone, it also integrates seamlessly with any L

 ## Additional resources

- [Guides](https://langchain-ai.github.io/langgraph/guides/): Quick, actionable code snippets for topics such as streaming, adding memory & persistence, and design patterns (e.g. branching, subgraphs, etc.).
+- [Guides](https://langchain-ai.github.io/langgraph/how-tos/): Quick, actionable code snippets for topics such as streaming, adding memory & persistence, and design patterns (e.g. branching, subgraphs, etc.).
 - [Reference](https://langchain-ai.github.io/langgraph/reference/graphs/): Detailed reference on core classes, methods, how to use the graph and checkpointing APIs, and higher-level prebuilt components.
 - [Examples](https://langchain-ai.github.io/langgraph/examples/): 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.
@@ -1,7 +1,7 @@
 from __future__ import annotations

 from collections import ChainMap
-from collections.abc import Mapping, Sequence
+from collections.abc import Sequence
 from os import getenv
 from typing import Any, cast

@@ -312,22 +312,11 @@ def ensure_config(*configs: RunnableConfig | None) -> RunnableConfig:
        for k, v in config.items():
            if _is_not_empty(v) and k not in CONFIG_KEYS:
                empty[CONF][k] = v
-    _empty_metadata = empty["metadata"]
    for key, value in empty[CONF].items():
-        if _exclude_as_metadata(key, value, _empty_metadata):
-            continue
-        _empty_metadata[key] = value
+        if (
+            not key.startswith("__")
+            and isinstance(value, (str, int, float, bool))
+            and key not in empty["metadata"]
+        ):
+            empty["metadata"][key] = value
    return empty
-
-
-_OMIT = ("key", "token", "secret", "password", "auth")
-
-
-def _exclude_as_metadata(key: str, value: Any, metadata: Mapping[str, Any]) -> bool:
-    key_lower = key.casefold()
-    return (
-        key.startswith("__")
-        or not isinstance(value, (str, int, float, bool))
-        or key in metadata
-        or any(substr in key_lower for substr in _OMIT)
-    )
@@ -25,7 +25,7 @@ from typing import (

 from langchain_core.runnables import Runnable, RunnableConfig
 from pydantic import BaseModel, TypeAdapter
-from typing_extensions import NotRequired, Required, Self, Unpack, is_typeddict
+from typing_extensions import Self, Unpack, is_typeddict

 from langgraph._internal._constants import (
    INTERRUPT,
@@ -155,7 +155,7 @@ class StateGraph(Generic[StateT, ContextT, InputT, OutputT]):
        graph = StateGraph(state_schema=State, context_schema=Context)

        def node(state: State, runtime: Runtime[Context]) -> dict:
-            r = runtime.context.get("r", 1.0)
+            r = runtie.context.get("r", 1.0)
            x = state["x"][-1]
            next_value = x * r * (1 - x)
            return {"x": next_value}
@@ -1334,12 +1334,6 @@ def _get_channel(
 def _get_channel(
    name: str, annotation: Any, *, allow_managed: bool = True
 ) -> BaseChannel | ManagedValueSpec:
-    # Strip out Required and NotRequired wrappers
-    if hasattr(annotation, "__origin__") and annotation.__origin__ in (
-        Required,
-        NotRequired,
-    ):
-        annotation = annotation.__args__[0]
    if manager := _is_field_managed_value(name, annotation):
        if allow_managed:
            return manager
@@ -194,12 +194,15 @@ def local_read(
        for c, v in task.writes:
            if c in select:
                updated[c].append(v)
-    if fresh:
+    if fresh and updated:
        # apply writes
        local_channels: dict[str, BaseChannel] = {}
        for k in channels:
-            cc = channels[k].copy()
-            cc.update(updated[k])
+            if k in updated:
+                cc = channels[k].copy()
+                cc.update(updated[k])
+            else:
+                cc = channels[k]
            local_channels[k] = cc
        # read fresh values
        values = read_channels(local_channels, select)
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"

 [project]
 name = "langgraph"
-version = "0.6.8"
+version = "0.6.6"
 description = "Building stateful, multi-actor applications with LLMs"
 authors = []
 requires-python = ">=3.9"
@@ -10,7 +10,6 @@ from langchain_core.runnables import RunnableConfig
 from pydantic import BaseModel
 from typing_extensions import NotRequired, Required, TypedDict

-from langgraph.channels.binop import BinaryOperatorAggregate
 from langgraph.graph.state import StateGraph, _get_node_name, _warn_invalid_state_schema


@@ -138,7 +137,7 @@ def test_state_schema_optional_values(total_: bool):
    class InputState(SomeParentState, total=total_):  # type: ignore
        val1: str
        val2: Optional[str]
-        val3: Required[Annotated[dict, operator.or_]]
+        val3: Required[str]
        val4: NotRequired[dict]
        val5: Annotated[Required[str], "foo"]
        val6: Annotated[NotRequired[str], "bar"]
@@ -160,8 +159,6 @@ def test_state_schema_optional_values(total_: bool):
    graph = builder.compile()
    json_schema = graph.get_input_jsonschema()

-    assert isinstance(graph.channels["val3"], BinaryOperatorAggregate)
-
    if total_ is False:
        expected_required = set()
        expected_optional = {"val2", "val1"}
@@ -17,13 +17,16 @@ import langsmith
 import pytest
 from typing_extensions import NotRequired, Required, TypedDict

-from langgraph._internal._config import _is_not_empty, ensure_config
+from langgraph._internal._config import _is_not_empty
 from langgraph._internal._fields import (
    _is_optional_type,
    get_enhanced_type_hints,
    get_field_default,
 )
-from langgraph._internal._runnable import is_async_callable, is_async_generator
+from langgraph._internal._runnable import (
+    is_async_callable,
+    is_async_generator,
+)
 from langgraph.constants import END
 from langgraph.graph import StateGraph
 from langgraph.graph.state import CompiledStateGraph
@@ -298,24 +301,3 @@ def test_is_not_empty() -> None:
    assert not _is_not_empty([])
    assert not _is_not_empty(())
    assert not _is_not_empty({})
-
-
-def test_configurable_metadata():
-    config = {
-        "configurable": {
-            "a-key": "foo",
-            "somesecretval": "bar",
-            "sometoken": "thetoken",
-            "__dontinclude": "bar",
-            "includeme": "hi",
-            "andme": 42,
-            "nested": {"foo": "bar"},
-            "nooverride": -2,
-        },
-        "metadata": {"nooverride": 18},
-    }
-    expected = {"includeme", "andme", "nooverride"}
-    merged = ensure_config(config)
-    metadata = merged["metadata"]
-    assert metadata.keys() == expected
-    assert metadata["nooverride"] == 18
@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 2
 requires-python = ">=3.9"
 resolution-markers = [
    "python_full_version >= '3.14'",
@@ -1269,7 +1269,7 @@ wheels = [

 [[package]]
 name = "langgraph"
-version = "0.6.8"
+version = "0.6.6"
 source = { editable = "." }
 dependencies = [
    { name = "langchain-core" },
@@ -390,14 +390,6 @@ def create_react_agent(
        state_schema: An optional state schema that defines graph state.
            Must have `messages` and `remaining_steps` keys.
            Defaults to `AgentState` that defines those two keys.
-            !!! Note
-                `remaining_steps` is used to limit the number of steps the react agent can take.
-                Calculated roughly as `recursion_limit` - `total_steps_taken`.
-                If `remaining_steps` is less than 2 and tool calls are present in the response,
-                the react agent will return a final AI Message with
-                the content "Sorry, need more steps to process this request.".
-                No `GraphRecusionError` will be raised in this case.
-
        context_schema: An optional schema for runtime context.
        checkpointer: An optional checkpoint saver object. This is used for persisting
            the state of the graph (e.g., as chat memory) for a single thread (e.g., a single conversation).
@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 2
 requires-python = ">=3.9"

 [[package]]
@@ -316,7 +316,7 @@ wheels = [

 [[package]]
 name = "langgraph"
-version = "0.6.8"
+version = "0.6.6"
 source = { editable = "../langgraph" }
 dependencies = [
    { name = "langchain-core" },
@@ -1,6 +1,6 @@
 from langgraph_sdk.auth import Auth
 from langgraph_sdk.client import get_client, get_sync_client

-__version__ = "0.2.6"
+__version__ = "0.2.3"

 __all__ = ["Auth", "get_client", "get_sync_client"]
@@ -400,20 +400,6 @@ class AuthContext(BaseAuthContext):
    """


-class ThreadTTL(typing.TypedDict, total=False):
-    """Time-to-live configuration for a thread.
-
-    Matches the OpenAPI schema where TTL is represented as an object with
-    an optional strategy and a time value in minutes.
-    """
-
-    strategy: typing.Literal["delete"]
-    """TTL strategy. Currently only 'delete' is supported."""
-
-    ttl: int
-    """Time-to-live in minutes from now until the thread should be swept."""
-
-
 class ThreadsCreate(typing.TypedDict, total=False):
    """Parameters for creating a new thread.

@@ -436,9 +422,6 @@ class ThreadsCreate(typing.TypedDict, total=False):
    if_exists: OnConflictBehavior
    """Behavior when a thread with the same ID already exists."""

-    ttl: ThreadTTL
-    """Optional TTL configuration for the thread."""
-

 class ThreadsRead(typing.TypedDict, total=False):
    """Parameters for reading thread state or run information.
@@ -506,9 +489,6 @@ class ThreadsSearch(typing.TypedDict, total=False):
    offset: int
    """Offset for pagination."""

-    ids: Sequence[UUID] | None
-    """typing.Optional list of thread IDs to filter by."""
-
    thread_id: UUID | None
    """typing.Optional thread ID to filter by."""

@@ -71,7 +71,6 @@ from langgraph_sdk.schema import (
    ThreadSortBy,
    ThreadState,
    ThreadStatus,
-    ThreadStreamMode,
    ThreadUpdateStateResponse,
 )
 from langgraph_sdk.sse import SSEDecoder, aiter_lines_raw, iter_lines_raw
@@ -157,38 +156,27 @@ def get_client(
    headers: Mapping[str, str] | None = None,
    timeout: TimeoutTypes | None = None,
 ) -> LangGraphClient:
-    """Create and configure a LangGraphClient.
-
-    The client provides programmatic access to a LangGraph Platform deployment. It supports
-    both remote servers and local in-process connections (when running inside a LangGraph server).
+    """Get a LangGraphClient instance.

    Args:
-        url:
-            Base URL of the LangGraph API.
-            – If `None`, the client first attempts an in-process connection via ASGI transport.
-              If that fails, it falls back to `http://localhost:8123`.
-        api_key:
-            API key for authentication. If omitted, the client reads from environment
-            variables in the following order:
-              1. Function argument
-              2. `LANGGRAPH_API_KEY`
-              3. `LANGSMITH_API_KEY`
-              4. `LANGCHAIN_API_KEY`
-        headers:
-            Additional HTTP headers to include in requests. Merged with authentication headers.
-        timeout:
-            HTTP timeout configuration. May be:
-              – `httpx.Timeout` instance
-              – float (total seconds)
-              – tuple `(connect, read, write, pool)` in seconds
-            Defaults: connect=5, read=300, write=300, pool=5.
+        url: The URL of the LangGraph API.
+        api_key: The API key. If not provided, it will be read from the environment.
+            Precedence:
+                1. explicit argument
+                2. LANGGRAPH_API_KEY
+                3. LANGSMITH_API_KEY
+                4. LANGCHAIN_API_KEY
+        headers: Optional custom headers
+        timeout: Optional timeout configuration for the HTTP client.
+            Accepts an httpx.Timeout instance, a float (seconds), or a tuple of timeouts.
+            Tuple format is (connect, read, write, pool)
+            If not provided, defaults to connect=5s, read=300s, write=300s, and pool=5s.

    Returns:
-        LangGraphClient:
-            A top-level client exposing sub-clients for assistants, threads,
-            runs, and cron operations.
+        LangGraphClient: The top-level client for accessing AssistantsClient,
+        ThreadsClient, RunsClient, and CronClient.

-    ???+ example "Connect to a remote server:"
+    ???+ example "Example"

        ```python
        from langgraph_sdk import get_client
@@ -199,21 +187,6 @@ def get_client(
        # example usage: client.<model>.<method_name>()
        assistants = await client.assistants.get(assistant_id="some_uuid")
        ```
-
-    ???+ example "Connect in-process to a running LangGraph server:"
-
-        ```python
-        from langgraph_sdk import get_client
-
-        client = get_client(url=None)
-
-        async def my_node(...):
-            subagent_result = await client.runs.wait(
-                thread_id=None,
-                assistant_id="agent",
-                input={"messages": [{"role": "user", "content": "Foo"}]},
-            )
-        ```
    """

    transport: httpx.AsyncBaseTransport | None = None
@@ -1205,7 +1178,6 @@ class ThreadsClient:
        if_exists: OnConflictBehavior | None = None,
        supersteps: Sequence[dict[str, Sequence[dict[str, Any]]]] | None = None,
        graph_id: str | None = None,
-        ttl: int | Mapping[str, Any] | None = None,
        headers: Mapping[str, str] | None = None,
        params: QueryParamTypes | None = None,
    ) -> Thread:
@@ -1220,9 +1192,6 @@ class ThreadsClient:
            supersteps: Apply a list of supersteps when creating a thread, each containing a sequence of updates.
                Each update has `values` or `command` and `as_node`. Used for copying a thread between deployments.
            graph_id: Optional graph ID to associate with the thread.
-            ttl: Optional time-to-live in minutes for the thread. You can pass an
-                integer (minutes) or a mapping with keys `ttl` and optional
-                `strategy` (defaults to "delete").
            headers: Optional custom headers to include with the request.
            params: Optional query parameters to include with the request.

@@ -1264,11 +1233,6 @@ class ThreadsClient:
                }
                for s in supersteps
            ]
-        if ttl is not None:
-            if isinstance(ttl, (int, float)):
-                payload["ttl"] = {"ttl": ttl, "strategy": "delete"}
-            else:
-                payload["ttl"] = ttl

        return await self.http.post(
            "/threads", json=payload, headers=headers, params=params
@@ -1279,7 +1243,6 @@ class ThreadsClient:
        thread_id: str,
        *,
        metadata: Mapping[str, Any],
-        ttl: int | Mapping[str, Any] | None = None,
        headers: Mapping[str, str] | None = None,
        params: QueryParamTypes | None = None,
    ) -> Thread:
@@ -1288,9 +1251,6 @@ class ThreadsClient:
        Args:
            thread_id: ID of thread to update.
            metadata: Metadata to merge with existing thread metadata.
-            ttl: Optional time-to-live in minutes for the thread. You can pass an
-                integer (minutes) or a mapping with keys `ttl` and optional
-                `strategy` (defaults to "delete").
            headers: Optional custom headers to include with the request.
            params: Optional query parameters to include with the request.

@@ -1304,19 +1264,12 @@ class ThreadsClient:
            thread = await client.threads.update(
                thread_id="my-thread-id",
                metadata={"number":1},
-                ttl=43_200,
            )
            ```
        """  # noqa: E501
-        payload: dict[str, Any] = {"metadata": metadata}
-        if ttl is not None:
-            if isinstance(ttl, (int, float)):
-                payload["ttl"] = {"ttl": ttl, "strategy": "delete"}
-            else:
-                payload["ttl"] = ttl
        return await self.http.patch(
            f"/threads/{thread_id}",
-            json=payload,
+            json={"metadata": metadata},
            headers=headers,
            params=params,
        )
@@ -1355,7 +1308,6 @@ class ThreadsClient:
        *,
        metadata: Json = None,
        values: Json = None,
-        ids: Sequence[str] | None = None,
        status: ThreadStatus | None = None,
        limit: int = 10,
        offset: int = 0,
@@ -1370,7 +1322,6 @@ class ThreadsClient:
        Args:
            metadata: Thread metadata to filter on.
            values: State values to filter on.
-            ids: List of thread IDs to filter by.
            status: Thread status to filter on.
                Must be one of 'idle', 'busy', 'interrupted' or 'error'.
            limit: Limit on number of threads to return.
@@ -1404,8 +1355,6 @@ class ThreadsClient:
            payload["metadata"] = metadata
        if values:
            payload["values"] = values
-        if ids:
-            payload["ids"] = ids
        if status:
            payload["status"] = status
        if sort_by:
@@ -1735,53 +1684,6 @@ class ThreadsClient:
            params=params,
        )

-    async def join_stream(
-        self,
-        thread_id: str,
-        *,
-        last_event_id: str | None = None,
-        stream_mode: ThreadStreamMode | Sequence[ThreadStreamMode] = "run_modes",
-        headers: Mapping[str, str] | None = None,
-        params: QueryParamTypes | None = None,
-    ) -> AsyncIterator[StreamPart]:
-        """Get a stream of events for a thread.
-
-        Args:
-            thread_id: The ID of the thread to get the stream for.
-            last_event_id: The ID of the last event to get.
-            headers: Optional custom headers to include with the request.
-            params: Optional query parameters to include with the request.
-
-        Returns:
-            Iterator[StreamPart]: An iterator of stream parts.
-
-        ???+ example "Example Usage"
-
-            ```python
-
-            for chunk in client.threads.join_stream(
-                thread_id="my_thread_id",
-                last_event_id="my_event_id",
-            ):
-                print(chunk)
-            ```
-
-        """  # noqa: E501
-        query_params = {
-            "stream_mode": stream_mode,
-        }
-        if params:
-            query_params.update(params)
-        return self.http.stream(
-            f"/threads/{thread_id}/stream",
-            "GET",
-            headers={
-                **({"Last-Event-ID": last_event_id} if last_event_id else {}),
-                **(headers or {}),
-            },
-            params=query_params,
-        )
-

 class RunsClient:
    """Client for managing runs in LangGraph.
@@ -4378,7 +4280,6 @@ class SyncThreadsClient:
        if_exists: OnConflictBehavior | None = None,
        supersteps: Sequence[dict[str, Sequence[dict[str, Any]]]] | None = None,
        graph_id: str | None = None,
-        ttl: int | Mapping[str, Any] | None = None,
        headers: Mapping[str, str] | None = None,
        params: QueryParamTypes | None = None,
    ) -> Thread:
@@ -4393,9 +4294,6 @@ class SyncThreadsClient:
            supersteps: Apply a list of supersteps when creating a thread, each containing a sequence of updates.
                Each update has `values` or `command` and `as_node`. Used for copying a thread between deployments.
            graph_id: Optional graph ID to associate with the thread.
-            ttl: Optional time-to-live in minutes for the thread. You can pass an
-                integer (minutes) or a mapping with keys `ttl` and optional
-                `strategy` (defaults to "delete").
            headers: Optional custom headers to include with the request.

        Returns:
@@ -4437,11 +4335,6 @@ class SyncThreadsClient:
                }
                for s in supersteps
            ]
-        if ttl is not None:
-            if isinstance(ttl, (int, float)):
-                payload["ttl"] = {"ttl": ttl, "strategy": "delete"}
-            else:
-                payload["ttl"] = ttl

        return self.http.post("/threads", json=payload, headers=headers, params=params)

@@ -4450,7 +4343,6 @@ class SyncThreadsClient:
        thread_id: str,
        *,
        metadata: Mapping[str, Any],
-        ttl: int | Mapping[str, Any] | None = None,
        headers: Mapping[str, str] | None = None,
        params: QueryParamTypes | None = None,
    ) -> Thread:
@@ -4459,11 +4351,7 @@ class SyncThreadsClient:
        Args:
            thread_id: ID of thread to update.
            metadata: Metadata to merge with existing thread metadata.
-            ttl: Optional time-to-live in minutes for the thread. You can pass an
-                integer (minutes) or a mapping with keys `ttl` and optional
-                `strategy` (defaults to "delete").
            headers: Optional custom headers to include with the request.
-            params: Optional query parameters to include with the request.

        Returns:
            Thread: The created thread.
@@ -4475,19 +4363,12 @@ class SyncThreadsClient:
            thread = client.threads.update(
                thread_id="my-thread-id",
                metadata={"number":1},
-                ttl=43_200,
            )
            ```
        """  # noqa: E501
-        payload: dict[str, Any] = {"metadata": metadata}
-        if ttl is not None:
-            if isinstance(ttl, (int, float)):
-                payload["ttl"] = {"ttl": ttl, "strategy": "delete"}
-            else:
-                payload["ttl"] = ttl
        return self.http.patch(
            f"/threads/{thread_id}",
-            json=payload,
+            json={"metadata": metadata},
            headers=headers,
            params=params,
        )
@@ -4525,7 +4406,6 @@ class SyncThreadsClient:
        *,
        metadata: Json = None,
        values: Json = None,
-        ids: Sequence[str] | None = None,
        status: ThreadStatus | None = None,
        limit: int = 10,
        offset: int = 0,
@@ -4540,7 +4420,6 @@ class SyncThreadsClient:
        Args:
            metadata: Thread metadata to filter on.
            values: State values to filter on.
-            ids: List of thread IDs to filter by.
            status: Thread status to filter on.
                Must be one of 'idle', 'busy', 'interrupted' or 'error'.
            limit: Limit on number of threads to return.
@@ -4570,8 +4449,6 @@ class SyncThreadsClient:
            payload["metadata"] = metadata
        if values:
            payload["values"] = values
-        if ids:
-            payload["ids"] = ids
        if status:
            payload["status"] = status
        if sort_by:
@@ -4895,54 +4772,6 @@ class SyncThreadsClient:
            params=params,
        )

-    def join_stream(
-        self,
-        thread_id: str,
-        *,
-        stream_mode: ThreadStreamMode | Sequence[ThreadStreamMode] = "run_modes",
-        last_event_id: str | None = None,
-        headers: Mapping[str, str] | None = None,
-        params: QueryParamTypes | None = None,
-    ) -> Iterator[StreamPart]:
-        """Get a stream of events for a thread.
-
-        Args:
-            thread_id: The ID of the thread to get the stream for.
-            last_event_id: The ID of the last event to get.
-            headers: Optional custom headers to include with the request.
-            params: Optional query parameters to include with the request.
-
-        Returns:
-            Iterator[StreamPart]: An iterator of stream parts.
-
-        ???+ example "Example Usage"
-
-            ```python
-
-            for chunk in client.threads.join_stream(
-                thread_id="my_thread_id",
-                last_event_id="my_event_id",
-                stream_mode="run_modes",
-            ):
-                print(chunk)
-            ```
-
-        """  # noqa: E501
-        query_params = {
-            "stream_mode": stream_mode,
-        }
-        if params:
-            query_params.update(params)
-        return self.http.stream(
-            f"/threads/{thread_id}/stream",
-            "GET",
-            headers={
-                **({"Last-Event-ID": last_event_id} if last_event_id else {}),
-                **(headers or {}),
-            },
-            params=query_params,
-        )
-

 class SyncRunsClient:
    """Synchronous client for managing runs in LangGraph.
@@ -38,14 +38,6 @@ Represents the status of a thread:
 - "error": An exception occurred during task processing.
 """

-ThreadStreamMode = Literal["run_modes", "lifecycle", "state_update"]
-"""
-Defines the mode of streaming:
- "run_modes": Stream the same events as the runs on thread, as well as run_done events.
- "lifecycle": Stream only run start/end events.
- "state_update": Stream state updates on the thread.
-"""
-
 StreamMode = Literal[
    "values",
    "messages",