wololo

Add some conformance tests for checkpointer implementations. Includes
additona methods that will be useful if you want to integarte in the
agent server.

.github/dependabot.yml

@@ -4,15 +4,108 @@ updates:
     directory: "/"
     schedule:
       interval: "weekly"
+      day: "monday"
+    groups:
+      all-dependencies:
+        patterns:
+          - "*"
 
-  - package-ecosystem: "pip"
-    directories:
-      - "libs/checkpoint"
-      - "libs/checkpoint-postgres"
-      - "libs/checkpoint-sqlite"
-      - "libs/cli"
-      - "libs/langgraph"
-      - "libs/prebuilt"
-      - "libs/sdk-py"
+  - package-ecosystem: "uv"
+    directory: "/libs/checkpoint"
     schedule:
       interval: "weekly"
+      day: "monday"
+    groups:
+      all-dependencies:
+        patterns:
+          - "*"
+  - package-ecosystem: "uv"
+    directory: "/libs/checkpoint-conformance"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+    groups:
+      all-dependencies:
+        patterns:
+          - "*"
+
+
+  - package-ecosystem: "uv"
+    directory: "/libs/checkpoint-postgres"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+    groups:
+      all-dependencies:
+        patterns:
+          - "*"
+
+  - package-ecosystem: "uv"
+    directory: "/libs/checkpoint-sqlite"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+    groups:
+      all-dependencies:
+        patterns:
+          - "*"
+
+  - package-ecosystem: "uv"
+    directory: "/libs/cli"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+    groups:
+      all-dependencies:
+        patterns:
+          - "*"
+
+  - package-ecosystem: "uv"
+    directory: "/libs/langgraph"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+    groups:
+      all-dependencies:
+        patterns:
+          - "*"
+
+  - package-ecosystem: "uv"
+    directory: "/libs/prebuilt"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+    groups:
+      all-dependencies:
+        patterns:
+          - "*"
+
+  - package-ecosystem: "uv"
+    directory: "/libs/sdk-py"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+    groups:
+      all-dependencies:
+        patterns:
+          - "*"
+
+  - package-ecosystem: "npm"
+    directory: "/libs/cli/js-examples"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+    groups:
+      all-dependencies:
+        patterns:
+          - "*"
+
+  - package-ecosystem: "npm"
+    directory: "/libs/cli/js-monorepo-example"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+    groups:
+      all-dependencies:
+        patterns:
+          - "*"

.github/scripts/run_langgraph_cli_test.py

@@ -63,7 +63,7 @@ def test(config: pathlib.Path, port: int, tag: str, verbose: bool):
             try:
                 sys.stderr.write("\n== docker compose ps ==\n")
                 runner.run(
-                    subp_exec(*compose_cmd, *args, "ps", input=stdin, verbose=False)
+                    subp_exec(*compose_cmd, *args, "ps", input=stdin, verbose=True)
                 )
             except Exception:
                 pass
@@ -76,7 +76,7 @@ def test(config: pathlib.Path, port: int, tag: str, verbose: bool):
                         "logs",
                         "langgraph-api",
                         input=stdin,
-                        verbose=False,
+                        verbose=True,
                     )
                 )
             except Exception:

.github/workflows/_integration_test.yml

@@ -2,6 +2,9 @@ name: CLI integration test
 
 on:
   workflow_call:
+    secrets:
+      LANGSMITH_API_KEY:
+        required: false
 
 permissions:
   contents: read
@@ -49,19 +52,22 @@ jobs:
       - name: Install cli globally
         if: steps.changed-files.outputs.all
         run: pip install -e .
-      - name: Build and test service ${{ matrix.example.name }}
+      - name: Build service ${{ matrix.example.name }}
         if: steps.changed-files.outputs.all
         working-directory: ${{ matrix.example.workdir }}
+        run: |
+          langgraph build -t ${{ matrix.example.tag }}
+      - name: Test service ${{ matrix.example.name }}
+        if: ${{ steps.changed-files.outputs.all && secrets.LANGSMITH_API_KEY != '' }}
+        working-directory: ${{ matrix.example.workdir }}
         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 && cp ../.env.example ../.env; fi
-          if [ -n "${{ secrets.LANGSMITH_API_KEY }}" ]; then echo "LANGSMITH_API_KEY=${{ secrets.LANGSMITH_API_KEY }}" >> .env; if [ -f ../.env ]; then echo "LANGSMITH_API_KEY=${{ secrets.LANGSMITH_API_KEY }}" >> ../.env; fi; fi
+          echo "LANGSMITH_API_KEY=${{ secrets.LANGSMITH_API_KEY }}" >> .env
+          if [ -f ../.env ]; then echo "LANGSMITH_API_KEY=${{ secrets.LANGSMITH_API_KEY }}" >> ../.env; fi
           # Run the integration test using the built tag
-          # 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 }}
 
@@ -82,22 +88,34 @@ jobs:
         working-directory: libs/cli/python-monorepo-example
         run: |
           langgraph build -t langgraph-test-g -c apps/agent/langgraph.json
+      - name: Test Python monorepo service
+        if: ${{ steps.changed-files.outputs.all && matrix.example.name == 'A' && secrets.LANGSMITH_API_KEY != '' }}
+        working-directory: libs/cli/python-monorepo-example
+        env:
+          LANGSMITH_API_KEY: ${{ secrets.LANGSMITH_API_KEY }}
+        run: |
           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
+          echo "LANGSMITH_API_KEY=${{ secrets.LANGSMITH_API_KEY }}" >> apps/agent/.env
           timeout 60 python ../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-g -c apps/agent/langgraph.json
 
-      - name: Build and test prerelease reqs service
+      - name: Build prerelease reqs service
         if: ${{ steps.changed-files.outputs.all && matrix.example.name == 'A' }}
         working-directory: libs/cli/examples/graph_prerelease_reqs
         run: |
           langgraph build -t langgraph-test-h
+      - name: Test prerelease reqs service
+        if: ${{ steps.changed-files.outputs.all && matrix.example.name == 'A' && secrets.LANGSMITH_API_KEY != '' }}
+        working-directory: libs/cli/examples/graph_prerelease_reqs
+        env:
+          LANGSMITH_API_KEY: ${{ secrets.LANGSMITH_API_KEY }}
+        run: |
           cp ../.env.example .env
-          if [ -n "${{ secrets.LANGSMITH_API_KEY }}" ]; then echo "LANGSMITH_API_KEY=${{ secrets.LANGSMITH_API_KEY }}" >> .env; fi
+          echo "LANGSMITH_API_KEY=${{ secrets.LANGSMITH_API_KEY }}" >> .env
           timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-h
           echo "Finished starting up langgraph-test-h"
           LANGGRAPH_VERSION=$(docker run --rm --entrypoint "" langgraph-test-h python -c "import sys; from importlib.metadata import version; v = version('langgraph'); print(v);")
-          if [ "$LANGGRAPH_VERSION" != "1.0.2" ]; then
-            echo "LANGGRAPH_VERSION != 1.0.2; $LANGGRAPH_VERSION"
+          if [ "$LANGGRAPH_VERSION" != "1.0.8" ]; then
+            echo "LANGGRAPH_VERSION != 1.0.8; $LANGGRAPH_VERSION"
             exit 1
           fi
           LANGCHAIN_OPENAI_VERSION=$(docker run --rm --entrypoint "" langgraph-test-h python -c "import sys; from importlib.metadata import version; v = version('langchain-openai'); print(v);")

.github/workflows/ci.yml

@@ -39,6 +39,7 @@ jobs:
               - 'libs/checkpoint/**'
               - 'libs/checkpoint-sqlite/**'
               - 'libs/checkpoint-postgres/**'
+              - 'libs/checkpoint-conformance/**'
               - 'libs/prebuilt/**'
             deps:
               - '**/pyproject.toml'
@@ -57,7 +58,7 @@ jobs:
             "libs/checkpoint",
             "libs/checkpoint-sqlite",
             "libs/checkpoint-postgres",
-
+            "libs/checkpoint-conformance",
             "libs/prebuilt",
           ]
     if: needs.changes.outputs.python == 'true' || needs.changes.outputs.deps == 'true'
@@ -77,6 +78,7 @@ jobs:
             "libs/checkpoint",
             "libs/checkpoint-sqlite",
             "libs/checkpoint-postgres",
+            "libs/checkpoint-conformance",
             "libs/prebuilt",
             "libs/sdk-py",
           ]

.github/workflows/cli-release.yml

@@ -0,0 +1,331 @@
+---
+name: CLI Release
+
+on:
+  push:
+    tags:
+      - 'cli-v*'
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: 'Release tag (e.g., cli-v0.2.10)'
+        required: true
+
+permissions:
+  contents: write
+  id-token: write  # OIDC trusted publishing for PyPI
+
+concurrency:
+  group: cli-release
+  cancel-in-progress: false
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  # ──────────────────────────────────────────────
+  # Build native binaries for each platform
+  # ──────────────────────────────────────────────
+  build:
+    name: Build - ${{ matrix.name }}
+    runs-on: ${{ matrix.runner }}
+    defaults:
+      run:
+        working-directory: libs/cli
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: linux-x64
+            runner: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+            binary: langgraph
+            npm_pkg: langgraph-cli-linux-x64
+
+          - name: linux-arm64
+            runner: ubuntu-24.04-arm
+            target: aarch64-unknown-linux-gnu
+            binary: langgraph
+            npm_pkg: langgraph-cli-linux-arm64
+
+          - name: darwin-x64
+            runner: macos-13  # Intel
+            target: x86_64-apple-darwin
+            binary: langgraph
+            npm_pkg: langgraph-cli-darwin-x64
+
+          - name: darwin-arm64
+            runner: macos-latest  # Apple Silicon
+            target: aarch64-apple-darwin
+            binary: langgraph
+            npm_pkg: langgraph-cli-darwin-arm64
+
+          - name: win32-x64
+            runner: windows-latest
+            target: x86_64-pc-windows-msvc
+            binary: langgraph.exe
+            npm_pkg: langgraph-cli-win32-x64
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
+
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: libs/cli
+          key: ${{ matrix.target }}
+
+      - name: Build release binary
+        run: cargo build --release --target ${{ matrix.target }}
+
+      - name: Run tests
+        if: matrix.name != 'linux-arm64'  # skip on ARM (slow QEMU)
+        run: cargo test --release --target ${{ matrix.target }}
+
+      # Upload raw binary for GitHub release
+      - name: Prepare binary artifact
+        shell: bash
+        run: |
+          mkdir -p dist
+          cp target/${{ matrix.target }}/release/${{ matrix.binary }} dist/
+          cd dist
+          if [[ "${{ matrix.name }}" == win32-* ]]; then
+            7z a ../langgraph-${{ matrix.name }}.zip ${{ matrix.binary }}
+          else
+            tar czf ../langgraph-${{ matrix.name }}.tar.gz ${{ matrix.binary }}
+          fi
+
+      - name: Upload binary artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: binary-${{ matrix.name }}
+          path: |
+            libs/cli/langgraph-${{ matrix.name }}.tar.gz
+            libs/cli/langgraph-${{ matrix.name }}.zip
+          if-no-files-found: ignore
+
+      # Prepare npm platform package
+      - name: Prepare npm platform package
+        shell: bash
+        run: |
+          cp target/${{ matrix.target }}/release/${{ matrix.binary }} npm/${{ matrix.npm_pkg }}/bin/
+
+      - name: Upload npm platform package
+        uses: actions/upload-artifact@v4
+        with:
+          name: npm-${{ matrix.name }}
+          path: libs/cli/npm/${{ matrix.npm_pkg }}/
+
+  # ──────────────────────────────────────────────
+  # Build Linux musl (Alpine-compatible) binary
+  # ──────────────────────────────────────────────
+  build-musl:
+    name: Build - linux-x64-musl
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: libs/cli
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: x86_64-unknown-linux-musl
+
+      - name: Install musl tools
+        run: sudo apt-get update && sudo apt-get install -y musl-tools
+
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: libs/cli
+          key: x86_64-unknown-linux-musl
+
+      - name: Build release binary
+        run: cargo build --release --target x86_64-unknown-linux-musl
+
+      - name: Prepare binary artifact
+        run: |
+          mkdir -p dist
+          cp target/x86_64-unknown-linux-musl/release/langgraph dist/
+          cd dist && tar czf ../langgraph-linux-x64-musl.tar.gz langgraph
+
+      - name: Upload binary artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: binary-linux-x64-musl
+          path: libs/cli/langgraph-linux-x64-musl.tar.gz
+
+  # ──────────────────────────────────────────────
+  # Build PyPI wheels via maturin
+  # ──────────────────────────────────────────────
+  pypi-wheels:
+    name: PyPI wheel - ${{ matrix.name }}
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: linux-x64
+            runner: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+            manylinux: manylinux_2_17
+
+          - name: linux-arm64
+            runner: ubuntu-24.04-arm
+            target: aarch64-unknown-linux-gnu
+            manylinux: manylinux_2_17
+
+          - name: linux-x64-musl
+            runner: ubuntu-latest
+            target: x86_64-unknown-linux-musl
+            manylinux: musllinux_1_2
+
+          - name: darwin-x64
+            runner: macos-13
+            target: x86_64-apple-darwin
+            manylinux: auto
+
+          - name: darwin-arm64
+            runner: macos-latest
+            target: aarch64-apple-darwin
+            manylinux: auto
+
+          - name: win32-x64
+            runner: windows-latest
+            target: x86_64-pc-windows-msvc
+            manylinux: auto
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build wheel
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: ${{ matrix.manylinux }}
+          args: --release --manifest-path libs/cli/Cargo.toml --out libs/cli/dist
+          rust-toolchain: stable
+
+      - name: Upload wheel
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheel-${{ matrix.name }}
+          path: libs/cli/dist/*.whl
+
+  # ──────────────────────────────────────────────
+  # Build sdist
+  # ──────────────────────────────────────────────
+  pypi-sdist:
+    name: PyPI sdist
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Build sdist
+        uses: PyO3/maturin-action@v1
+        with:
+          command: sdist
+          args: --manifest-path libs/cli/Cargo.toml --out libs/cli/dist
+
+      - name: Upload sdist
+        uses: actions/upload-artifact@v4
+        with:
+          name: sdist
+          path: libs/cli/dist/*.tar.gz
+
+  # ──────────────────────────────────────────────
+  # Publish to PyPI
+  # ──────────────────────────────────────────────
+  pypi-publish:
+    name: Publish to PyPI
+    needs: [pypi-wheels, pypi-sdist]
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/cli-v')
+    environment:
+      name: pypi
+      url: https://pypi.org/project/langgraph-cli/
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: wheel-*
+          path: dist
+          merge-multiple: true
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: sdist
+          path: dist
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+  # ──────────────────────────────────────────────
+  # Publish to npm
+  # ──────────────────────────────────────────────
+  npm-publish:
+    name: Publish to npm
+    needs: [build]
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/cli-v')
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          registry-url: "https://registry.npmjs.org"
+
+      # Download all npm platform packages
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: npm-*
+          path: npm-artifacts
+
+      # Publish each platform package
+      - name: Publish platform packages
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: |
+          for dir in npm-artifacts/npm-*/; do
+            echo "Publishing $(basename $dir)..."
+            cd "$dir"
+            npm publish --access public
+            cd -
+          done
+
+      # Publish the main package
+      - name: Publish main package
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: |
+          cd libs/cli/npm/langgraph-cli
+          npm publish --access public
+
+  # ──────────────────────────────────────────────
+  # Create GitHub Release with standalone binaries
+  # ──────────────────────────────────────────────
+  github-release:
+    name: GitHub Release
+    needs: [build, build-musl]
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/cli-v')
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: binary-*
+          path: release-artifacts
+          merge-multiple: true
+
+      - name: Create release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: release-artifacts/*
+          generate_release_notes: true
+          draft: false

.github/workflows/cli-rust.yml

@@ -0,0 +1,49 @@
+---
+name: CLI Rust
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'libs/cli/src/**'
+      - 'libs/cli/Cargo.toml'
+      - 'libs/cli/Cargo.lock'
+      - 'libs/cli/build.rs'
+  pull_request:
+    paths:
+      - 'libs/cli/src/**'
+      - 'libs/cli/Cargo.toml'
+      - 'libs/cli/Cargo.lock'
+      - 'libs/cli/build.rs'
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  check:
+    name: Check / Lint / Test
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: libs/cli
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt, clippy
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: libs/cli
+      - name: Format check
+        run: cargo fmt --check
+      - name: Clippy
+        run: cargo clippy -- -D warnings
+      - name: Test
+        run: cargo test
+      - name: Build release
+        run: cargo build --release

libs/checkpoint-conformance/Makefile

@@ -0,0 +1,12 @@
+.PHONY: format lint test
+
+format:
+	uv run ruff format .
+	uv run ruff check --fix .
+
+lint:
+	uv run ruff check .
+	uv run ty check
+
+test:
+	uv run pytest $(TEST)

libs/checkpoint-conformance/README.md

@@ -0,0 +1,111 @@
+# langgraph-checkpoint-conformance
+
+Conformance test suite for [LangGraph](https://github.com/langchain-ai/langgraph) checkpointer implementations.
+
+Validates that a `BaseCheckpointSaver` subclass correctly implements the checkpoint storage contract — blob round-trips, metadata preservation, namespace isolation, incremental channel updates, and more.
+
+## Installation
+
+```bash
+pip install langgraph-checkpoint-conformance
+```
+
+## Quick start
+
+Register your checkpointer with `@checkpointer_test` and run `validate()`:
+
+```python
+import asyncio
+from langgraph.checkpoint.conformance import checkpointer_test, validate
+
+@checkpointer_test(name="MyCheckpointer")
+async def my_checkpointer():
+    saver = MyCheckpointer(...)
+    yield saver
+    # cleanup runs after yield
+
+async def main():
+    report = await validate(my_checkpointer)
+    report.print_report()
+    assert report.passed_all_base()
+
+asyncio.run(main())
+```
+
+Or in a pytest test:
+
+```python
+import pytest
+from langgraph.checkpoint.conformance import checkpointer_test, validate
+
+@checkpointer_test(name="MyCheckpointer")
+async def my_checkpointer():
+    yield MyCheckpointer(...)
+
+@pytest.mark.asyncio
+async def test_conformance():
+    report = await validate(my_checkpointer)
+    report.print_report()
+    assert report.passed_all_base()
+```
+
+## Capabilities
+
+The suite tests **base** capabilities (required) and **extended** capabilities (optional, auto-detected):
+
+| Capability | Required | Method |
+|---|---|---|
+| `put` | yes | `aput` |
+| `put_writes` | yes | `aput_writes` |
+| `get_tuple` | yes | `aget_tuple` |
+| `list` | yes | `alist` |
+| `delete_thread` | yes | `adelete_thread` |
+| `delete_for_runs` | no | `adelete_for_runs` |
+| `copy_thread` | no | `acopy_thread` |
+| `prune` | no | `aprune` |
+
+Extended capabilities are detected by checking whether the method is overridden from `BaseCheckpointSaver`. If not overridden, those tests are skipped.
+
+## Options
+
+### Progress output
+
+```python
+from langgraph.checkpoint.conformance.report import ProgressCallbacks
+
+# Dot-style progress (. per pass, F per fail)
+report = await validate(my_checkpointer, progress=ProgressCallbacks.default())
+
+# Verbose (per-test names + stacktraces on failure)
+report = await validate(my_checkpointer, progress=ProgressCallbacks.verbose())
+```
+
+### Skip capabilities
+
+```python
+@checkpointer_test(name="MyCheckpointer", skip_capabilities={"prune"})
+async def my_checkpointer():
+    yield MyCheckpointer(...)
+```
+
+### Run specific capabilities
+
+```python
+report = await validate(my_checkpointer, capabilities={"put", "list"})
+```
+
+### Lifespan (one-time setup/teardown)
+
+For expensive setup like database creation:
+
+```python
+async def db_lifespan():
+    await create_database()
+    yield
+    await drop_database()
+
+@checkpointer_test(name="PostgresSaver", lifespan=db_lifespan)
+async def pg_checkpointer():
+    async with PostgresSaver.from_conn_string(CONN_STRING) as saver:
+        yield saver
+```

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

@@ -0,0 +1,9 @@
+"""langgraph-checkpoint-conformance: conformance test suite for checkpointer implementations."""
+
+from langgraph.checkpoint.conformance.initializer import checkpointer_test
+from langgraph.checkpoint.conformance.validate import validate
+
+__all__ = [
+    "checkpointer_test",
+    "validate",
+]

libs/checkpoint-conformance/langgraph/checkpoint/conformance/capabilities.py

@@ -0,0 +1,93 @@
+"""Capability detection for checkpointer implementations."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from langgraph.checkpoint.base import BaseCheckpointSaver
+
+if TYPE_CHECKING:
+    pass
+
+
+class Capability(str, Enum):
+    """Capabilities that a checkpointer may support."""
+
+    PUT = "put"
+    PUT_WRITES = "put_writes"
+    GET_TUPLE = "get_tuple"
+    LIST = "list"
+    DELETE_THREAD = "delete_thread"
+    DELETE_FOR_RUNS = "delete_for_runs"
+    COPY_THREAD = "copy_thread"
+    PRUNE = "prune"
+
+
+# Capabilities that every checkpointer must support.
+BASE_CAPABILITIES = frozenset(
+    {
+        Capability.PUT,
+        Capability.PUT_WRITES,
+        Capability.GET_TUPLE,
+        Capability.LIST,
+        Capability.DELETE_THREAD,
+    }
+)
+
+# Capabilities that are optional extensions.
+EXTENDED_CAPABILITIES = frozenset(
+    {
+        Capability.DELETE_FOR_RUNS,
+        Capability.COPY_THREAD,
+        Capability.PRUNE,
+    }
+)
+
+ALL_CAPABILITIES = BASE_CAPABILITIES | EXTENDED_CAPABILITIES
+
+# Maps capability to the async method name on BaseCheckpointSaver (or subclass).
+_CAPABILITY_METHOD_MAP: dict[Capability, str] = {
+    Capability.PUT: "aput",
+    Capability.PUT_WRITES: "aput_writes",
+    Capability.GET_TUPLE: "aget_tuple",
+    Capability.LIST: "alist",
+    Capability.DELETE_THREAD: "adelete_thread",
+    Capability.DELETE_FOR_RUNS: "adelete_for_runs",
+    Capability.COPY_THREAD: "acopy_thread",
+    Capability.PRUNE: "aprune",
+}
+
+
+@dataclass(frozen=True)
+class DetectedCapabilities:
+    """Result of capability detection for a checkpointer type."""
+
+    detected: frozenset[Capability]
+    missing: frozenset[Capability]
+
+    @classmethod
+    def from_instance(cls, saver: BaseCheckpointSaver) -> DetectedCapabilities:
+        """Detect capabilities from a checkpointer instance."""
+        inner_type = type(saver)
+        detected: set[Capability] = set()
+
+        for cap, method_name in _CAPABILITY_METHOD_MAP.items():
+            if _is_overridden(inner_type, method_name):
+                detected.add(cap)
+
+        detected_fs = frozenset(detected)
+        return cls(
+            detected=detected_fs,
+            missing=ALL_CAPABILITIES - detected_fs,
+        )
+
+
+def _is_overridden(inner_type: type, method: str) -> bool:
+    """Check if *method* on *inner_type* differs from the base class default."""
+    base = getattr(BaseCheckpointSaver, method, None)
+    impl = getattr(inner_type, method, None)
+    if base is None or impl is None:
+        return impl is not None
+    return impl is not base

libs/checkpoint-conformance/langgraph/checkpoint/conformance/initializer.py

@@ -0,0 +1,100 @@
+"""Checkpointer test registration and factory management."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator, Callable
+from contextlib import asynccontextmanager
+from dataclasses import dataclass, field
+from typing import Any
+
+from langgraph.checkpoint.base import BaseCheckpointSaver
+
+# Type for the lifespan async context manager factory.
+LifespanFactory = Callable[[], AsyncGenerator[None, None]]
+
+# Module-level registry of decorated checkpointer factories.
+_REGISTRY: dict[str, RegisteredCheckpointer] = {}
+
+
+async def _noop_lifespan() -> AsyncGenerator[None, None]:
+    yield
+
+
+@dataclass
+class RegisteredCheckpointer:
+    """A registered checkpointer test factory."""
+
+    name: str
+    factory: Callable[[], AsyncGenerator[BaseCheckpointSaver, None]]
+    skip_capabilities: set[str] = field(default_factory=set)
+    lifespan: LifespanFactory = _noop_lifespan
+
+    @asynccontextmanager
+    async def create(self) -> AsyncGenerator[BaseCheckpointSaver, None]:
+        """Create a fresh checkpointer instance via the async generator."""
+        gen = self.factory()
+        try:
+            saver = await gen.__anext__()
+            yield saver
+        finally:
+            try:
+                await gen.__anext__()
+            except StopAsyncIteration:
+                pass
+
+    @asynccontextmanager
+    async def enter_lifespan(self) -> AsyncGenerator[None, None]:
+        """Enter the lifespan context (once per validation run)."""
+        gen = self.lifespan()
+        try:
+            await gen.__anext__()
+            yield
+        finally:
+            try:
+                await gen.__anext__()
+            except StopAsyncIteration:
+                pass
+
+
+def checkpointer_test(
+    name: str,
+    *,
+    skip_capabilities: set[str] | None = None,
+    lifespan: LifespanFactory | None = None,
+) -> Callable[[Any], RegisteredCheckpointer]:
+    """Register an async generator as a checkpointer test factory.
+
+    The factory is called once per capability suite to create a fresh
+    checkpointer.  The optional `lifespan` is an async generator that
+    runs once for the entire validation run (e.g. to create/destroy a
+    database).
+
+    Example::
+
+        @checkpointer_test(name="InMemorySaver")
+        async def memory_checkpointer():
+            yield InMemorySaver()
+
+    With lifespan::
+
+        async def pg_lifespan():
+            await create_database()
+            yield
+            await drop_database()
+
+        @checkpointer_test(name="PostgresSaver", lifespan=pg_lifespan)
+        async def pg_checkpointer():
+            yield PostgresSaver(conn_string="...")
+    """
+
+    def decorator(fn: Any) -> RegisteredCheckpointer:
+        registered = RegisteredCheckpointer(
+            name=name,
+            factory=fn,
+            skip_capabilities=skip_capabilities or set(),
+            lifespan=lifespan or _noop_lifespan,
+        )
+        _REGISTRY[name] = registered
+        return registered
+
+    return decorator

libs/checkpoint-conformance/langgraph/checkpoint/conformance/report.py

@@ -0,0 +1,198 @@
+"""Capability report: results, progress callbacks, and pretty-printing."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+from langgraph.checkpoint.conformance.capabilities import (
+    BASE_CAPABILITIES,
+    EXTENDED_CAPABILITIES,
+    Capability,
+)
+
+# Callback type for per-test progress reporting.
+# (capability_name, test_name, passed, error_msg_or_None) -> None
+OnTestResult = Callable[[str, str, bool, str | None], None]
+
+# Callback type for capability-level events.
+# (capability_name, detected) -> None
+OnCapabilityStart = Callable[[str, bool], None]
+
+
+class ProgressCallbacks:
+    """Grouped callbacks for progress reporting during validation."""
+
+    def __init__(
+        self,
+        *,
+        on_capability_start: Callable[[str, bool], None] | None = None,
+        on_test_result: OnTestResult | None = None,
+        on_capability_end: Callable[[str], None] | None = None,
+    ) -> None:
+        self.on_capability_start = on_capability_start
+        self.on_test_result = on_test_result
+        self.on_capability_end = on_capability_end
+
+    @classmethod
+    def default(cls) -> ProgressCallbacks:
+        """Dot-style progress: ``.`` per pass, ``F`` per fail."""
+
+        def _cap_start(capability: str, detected: bool) -> None:
+            if detected:
+                print(f"  {capability}: ", end="", flush=True)
+            else:
+                print(f"  ⊘ {capability} (not implemented)")
+
+        def _test_result(
+            capability: str, test_name: str, passed: bool, error: str | None
+        ) -> None:
+            print("." if passed else "F", end="", flush=True)
+
+        def _cap_end(capability: str) -> None:
+            print()  # newline after dots
+
+        return cls(
+            on_capability_start=_cap_start,
+            on_test_result=_test_result,
+            on_capability_end=_cap_end,
+        )
+
+    @classmethod
+    def verbose(cls) -> ProgressCallbacks:
+        """Per-test output with names and errors."""
+
+        def _cap_start(capability: str, detected: bool) -> None:
+            if detected:
+                print(f"  {capability}:")
+            else:
+                print(f"  ⊘ {capability} (not implemented)")
+
+        def _test_result(
+            capability: str, test_name: str, passed: bool, error: str | None
+        ) -> None:
+            icon = "✓" if passed else "✗"
+            print(f"    {icon} {test_name}")
+            if error:
+                for line in error.rstrip().splitlines():
+                    print(f"      {line}")
+
+        return cls(
+            on_capability_start=_cap_start,
+            on_test_result=_test_result,
+        )
+
+    @classmethod
+    def quiet(cls) -> ProgressCallbacks:
+        """No progress output."""
+        return cls()
+
+
+@dataclass
+class CapabilityResult:
+    """Result of running a single capability's test suite."""
+
+    detected: bool = False
+    passed: bool | None = None  # None = skipped
+    tests_passed: int = 0
+    tests_failed: int = 0
+    tests_skipped: int = 0
+    failures: list[str] = field(default_factory=list)
+
+
+@dataclass
+class CapabilityReport:
+    """Aggregate report across all capabilities."""
+
+    checkpointer_name: str
+    results: dict[str, CapabilityResult] = field(default_factory=dict)
+
+    def passed_all_base(self) -> bool:
+        """Whether all base capability tests passed."""
+        for cap in BASE_CAPABILITIES:
+            result = self.results.get(cap.value)
+            if result is None or result.passed is not True:
+                return False
+        return True
+
+    def passed_all(self) -> bool:
+        """Whether every detected capability's tests passed."""
+        for result in self.results.values():
+            if result.detected and result.passed is not True:
+                return False
+        return True
+
+    def conformance_level(self) -> str:
+        """Return a human-readable conformance level string."""
+        if self.passed_all():
+            return "FULL"
+        if self.passed_all_base():
+            return "BASE+PARTIAL"
+        return "BASE" if self._any_base_passed() else "NONE"
+
+    def _any_base_passed(self) -> bool:
+        for cap in BASE_CAPABILITIES:
+            result = self.results.get(cap.value)
+            if result and result.passed is True:
+                return True
+        return False
+
+    def print_report(self) -> None:
+        """Pretty-print the report to stdout."""
+        width = 52
+        border = "=" * width
+        print(f"\n{'':>2}{border}")
+        print(f"{'':>2}  Checkpointer Validation: {self.checkpointer_name}")
+        print(f"{'':>2}{border}")
+
+        def _section(title: str, caps: frozenset[Capability]) -> None:
+            print(f"{'':>2}  {title}")
+            for cap in sorted(caps, key=lambda c: c.value):
+                result = self.results.get(cap.value)
+                if result is None:
+                    icon = "  "
+                    suffix = "(no tests)"
+                elif not result.detected:
+                    icon = "⊘ "
+                    suffix = "(not implemented)"
+                elif result.passed is True:
+                    icon = "✅"
+                    suffix = ""
+                elif result.passed is False:
+                    icon = "❌"
+                    suffix = f"({result.tests_failed} failed)"
+                else:
+                    icon = "⏭ "
+                    suffix = "(skipped)"
+                print(f"{'':>2}    {icon} {cap.value:20s} {suffix}")
+            print()
+
+        _section("BASE CAPABILITIES", BASE_CAPABILITIES)
+        _section("EXTENDED CAPABILITIES", EXTENDED_CAPABILITIES)
+
+        total = sum(1 for r in self.results.values() if r.detected)
+        passed = sum(
+            1 for r in self.results.values() if r.detected and r.passed is True
+        )
+        level = self.conformance_level()
+        print(f"{'':>2}  Result: {level} ({passed}/{total})")
+        print(f"{'':>2}{border}\n")
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return a JSON-serializable dict."""
+        return {
+            "checkpointer_name": self.checkpointer_name,
+            "conformance_level": self.conformance_level(),
+            "results": {
+                name: {
+                    "detected": r.detected,
+                    "passed": r.passed,
+                    "tests_passed": r.tests_passed,
+                    "tests_failed": r.tests_failed,
+                    "tests_skipped": r.tests_skipped,
+                    "failures": r.failures,
+                }
+                for name, r in self.results.items()
+            },
+        }

libs/checkpoint-conformance/langgraph/checkpoint/conformance/spec/__init__.py

@@ -0,0 +1,27 @@
+"""Test spec modules for each checkpointer capability."""
+
+from langgraph.checkpoint.conformance.spec.test_copy_thread import (
+    run_copy_thread_tests,
+)
+from langgraph.checkpoint.conformance.spec.test_delete_for_runs import (
+    run_delete_for_runs_tests,
+)
+from langgraph.checkpoint.conformance.spec.test_delete_thread import (
+    run_delete_thread_tests,
+)
+from langgraph.checkpoint.conformance.spec.test_get_tuple import run_get_tuple_tests
+from langgraph.checkpoint.conformance.spec.test_list import run_list_tests
+from langgraph.checkpoint.conformance.spec.test_prune import run_prune_tests
+from langgraph.checkpoint.conformance.spec.test_put import run_put_tests
+from langgraph.checkpoint.conformance.spec.test_put_writes import run_put_writes_tests
+
+__all__ = [
+    "run_put_tests",
+    "run_put_writes_tests",
+    "run_get_tuple_tests",
+    "run_list_tests",
+    "run_delete_thread_tests",
+    "run_delete_for_runs_tests",
+    "run_copy_thread_tests",
+    "run_prune_tests",
+]

libs/checkpoint-conformance/langgraph/checkpoint/conformance/spec/test_copy_thread.py

@@ -0,0 +1,250 @@
+"""COPY_THREAD capability tests — acopy_thread."""
+
+from __future__ import annotations
+
+import traceback
+from collections.abc import Callable
+from uuid import uuid4
+
+from langgraph.checkpoint.base import BaseCheckpointSaver
+
+from langgraph.checkpoint.conformance.test_utils import (
+    generate_checkpoint,
+    generate_config,
+    generate_metadata,
+)
+
+
+async def _setup_source_thread(
+    saver: BaseCheckpointSaver,
+    tid: str,
+    *,
+    n: int = 3,
+    namespaces: list[str] | None = None,
+) -> list[dict]:
+    """Create n checkpoints on tid (optionally across namespaces). Returns stored configs."""
+    nss = namespaces or [""]
+    stored = []
+    for ns in nss:
+        parent_cfg = None
+        for i in range(n):
+            config = generate_config(tid, checkpoint_ns=ns)
+            if parent_cfg:
+                config["configurable"]["checkpoint_id"] = parent_cfg["configurable"][
+                    "checkpoint_id"
+                ]
+            cp = generate_checkpoint(channel_values={"step": i})
+            cp["channel_versions"] = {"step": 1}
+            parent_cfg = await saver.aput(
+                config, cp, generate_metadata(step=i), {"step": 1}
+            )
+            stored.append(parent_cfg)
+    return stored
+
+
+async def test_copy_thread_basic(saver: BaseCheckpointSaver) -> None:
+    """Checkpoints appear on target thread."""
+    src = str(uuid4())
+    dst = str(uuid4())
+    await _setup_source_thread(saver, src)
+
+    await saver.acopy_thread(src, dst)
+    results = []
+    async for tup in saver.alist(generate_config(dst)):
+        results.append(tup)
+    assert len(results) == 3, f"Expected 3 copied checkpoints, got {len(results)}"
+
+
+async def test_copy_thread_all_checkpoints(saver: BaseCheckpointSaver) -> None:
+    """All checkpoints copied, not just latest."""
+    src = str(uuid4())
+    dst = str(uuid4())
+    await _setup_source_thread(saver, src, n=3)
+
+    await saver.acopy_thread(src, dst)
+    src_results = []
+    async for tup in saver.alist(generate_config(src)):
+        src_results.append(tup)
+
+    dst_results = []
+    async for tup in saver.alist(generate_config(dst)):
+        dst_results.append(tup)
+
+    assert len(dst_results) == len(src_results)
+    # Verify content matches
+    for s, d in zip(
+        sorted(src_results, key=lambda t: t.checkpoint["id"]),
+        sorted(dst_results, key=lambda t: t.checkpoint["id"]),
+        strict=True,
+    ):
+        assert s.checkpoint["channel_values"] == d.checkpoint["channel_values"], (
+            f"channel_values mismatch for checkpoint {s.checkpoint['id']}"
+        )
+
+
+async def test_copy_thread_preserves_metadata(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Metadata intact on copied checkpoints."""
+    src = str(uuid4())
+    dst = str(uuid4())
+    await _setup_source_thread(saver, src, n=2)
+
+    await saver.acopy_thread(src, dst)
+    src_tuples = []
+    async for tup in saver.alist(generate_config(src)):
+        src_tuples.append(tup)
+
+    dst_tuples = []
+    async for tup in saver.alist(generate_config(dst)):
+        dst_tuples.append(tup)
+
+    for s, d in zip(
+        sorted(src_tuples, key=lambda t: t.metadata.get("step", 0)),
+        sorted(dst_tuples, key=lambda t: t.metadata.get("step", 0)),
+        strict=True,
+    ):
+        for key in s.metadata:
+            assert s.metadata.get(key) == d.metadata.get(key), (
+                f"metadata[{key!r}] mismatch: {s.metadata.get(key)!r} != {d.metadata.get(key)!r}"
+            )
+
+
+async def test_copy_thread_preserves_namespaces(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Root + child namespaces copied."""
+    src = str(uuid4())
+    dst = str(uuid4())
+    await _setup_source_thread(saver, src, n=1, namespaces=["", "child:1"])
+
+    await saver.acopy_thread(src, dst)
+    for ns in ["", "child:1"]:
+        results = []
+        async for tup in saver.alist(generate_config(dst, checkpoint_ns=ns)):
+            results.append(tup)
+        assert len(results) == 1, (
+            f"Expected 1 checkpoint in namespace '{ns}', got {len(results)}"
+        )
+
+
+async def test_copy_thread_preserves_writes(saver: BaseCheckpointSaver) -> None:
+    """Pending writes copied."""
+    src = str(uuid4())
+    dst = str(uuid4())
+    configs = await _setup_source_thread(saver, src, n=1)
+
+    # Add a write to the source
+    await saver.aput_writes(configs[-1], [("ch", "write_val")], str(uuid4()))
+
+    await saver.acopy_thread(src, dst)
+    tup = await saver.aget_tuple(generate_config(dst))
+    assert tup is not None
+    assert tup.pending_writes is not None
+    assert len(tup.pending_writes) == 1, (
+        f"Expected 1 write, got {len(tup.pending_writes)}"
+    )
+    assert tup.pending_writes[0][1] == "ch", (
+        f"channel mismatch: {tup.pending_writes[0][1]!r}"
+    )
+    assert tup.pending_writes[0][2] == "write_val", (
+        f"value mismatch: {tup.pending_writes[0][2]!r}"
+    )
+
+
+async def test_copy_thread_preserves_ordering(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Checkpoint order maintained."""
+    src = str(uuid4())
+    dst = str(uuid4())
+    await _setup_source_thread(saver, src, n=4)
+
+    await saver.acopy_thread(src, dst)
+    src_ids = []
+    async for tup in saver.alist(generate_config(src)):
+        src_ids.append(tup.checkpoint["id"])
+
+    dst_ids = []
+    async for tup in saver.alist(generate_config(dst)):
+        dst_ids.append(tup.checkpoint["id"])
+
+    # Order should match (both newest-first)
+    assert src_ids == dst_ids
+
+
+async def test_copy_thread_source_unchanged(saver: BaseCheckpointSaver) -> None:
+    """Source thread still intact after copy."""
+    src = str(uuid4())
+    dst = str(uuid4())
+    await _setup_source_thread(saver, src, n=2)
+
+    # Snapshot source before copy
+    src_before = []
+    async for tup in saver.alist(generate_config(src)):
+        src_before.append(tup.checkpoint["id"])
+
+    await saver.acopy_thread(src, dst)
+    # Source should be unchanged
+    src_after = []
+    async for tup in saver.alist(generate_config(src)):
+        src_after.append(tup.checkpoint["id"])
+
+    assert src_before == src_after
+
+
+async def test_copy_thread_nonexistent_source(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Graceful handling of non-existent source thread."""
+    src = str(uuid4())
+    dst = str(uuid4())
+
+    # Should not raise (or raise a known error)
+    try:
+        await saver.acopy_thread(src, dst)
+    except Exception:
+        pass  # Some implementations may raise; that's acceptable
+
+    # Destination should be empty
+    results = []
+    async for tup in saver.alist(generate_config(dst)):
+        results.append(tup)
+    assert len(results) == 0
+
+
+ALL_COPY_THREAD_TESTS = [
+    test_copy_thread_basic,
+    test_copy_thread_all_checkpoints,
+    test_copy_thread_preserves_metadata,
+    test_copy_thread_preserves_namespaces,
+    test_copy_thread_preserves_writes,
+    test_copy_thread_preserves_ordering,
+    test_copy_thread_source_unchanged,
+    test_copy_thread_nonexistent_source,
+]
+
+
+async def run_copy_thread_tests(
+    saver: BaseCheckpointSaver,
+    on_test_result: Callable[[str, str, bool, str | None], None] | None = None,
+) -> tuple[int, int, list[str]]:
+    """Run all copy_thread tests. Returns (passed, failed, failure_names)."""
+    passed = 0
+    failed = 0
+    failures: list[str] = []
+    for test_fn in ALL_COPY_THREAD_TESTS:
+        try:
+            await test_fn(saver)
+            passed += 1
+            if on_test_result:
+                on_test_result("copy_thread", test_fn.__name__, True, None)
+        except Exception as e:
+            failed += 1
+            msg = f"{test_fn.__name__}: {e}"
+            failures.append(msg)
+            if on_test_result:
+                on_test_result(
+                    "copy_thread", test_fn.__name__, False, traceback.format_exc()
+                )
+    return passed, failed, failures

libs/checkpoint-conformance/langgraph/checkpoint/conformance/spec/test_delete_for_runs.py

@@ -0,0 +1,218 @@
+"""DELETE_FOR_RUNS capability tests — adelete_for_runs."""
+
+from __future__ import annotations
+
+import traceback
+from collections.abc import Callable
+from uuid import uuid4
+
+from langgraph.checkpoint.base import BaseCheckpointSaver
+
+from langgraph.checkpoint.conformance.test_utils import (
+    generate_checkpoint,
+    generate_config,
+    generate_metadata,
+)
+
+
+async def _put_with_run_id(
+    saver: BaseCheckpointSaver,
+    tid: str,
+    run_id: str,
+    *,
+    checkpoint_ns: str = "",
+    parent_config: dict | None = None,
+) -> dict:
+    """Put a checkpoint with a run_id in metadata, return stored config."""
+    config = generate_config(tid, checkpoint_ns=checkpoint_ns)
+    if parent_config:
+        config["configurable"]["checkpoint_id"] = parent_config["configurable"][
+            "checkpoint_id"
+        ]
+    cp = generate_checkpoint()
+    md = generate_metadata(run_id=run_id)
+    return await saver.aput(config, cp, md, {})
+
+
+async def test_delete_for_runs_single(saver: BaseCheckpointSaver) -> None:
+    """One run_id removed."""
+    tid = str(uuid4())
+    run1, run2 = str(uuid4()), str(uuid4())
+
+    stored1 = await _put_with_run_id(saver, tid, run1)
+    await _put_with_run_id(saver, tid, run2, parent_config=stored1)
+
+    # Pre-delete: verify both runs exist
+    pre_results = []
+    async for tup in saver.alist(generate_config(tid)):
+        pre_results.append(tup)
+    pre_run_ids = {t.metadata.get("run_id") for t in pre_results}
+    assert run1 in pre_run_ids, "Pre-delete: run1 should exist"
+    assert run2 in pre_run_ids, "Pre-delete: run2 should exist"
+
+    await saver.adelete_for_runs([run1])
+    # run1's checkpoint should be gone; run2 should remain
+    results = []
+    async for tup in saver.alist(generate_config(tid)):
+        results.append(tup)
+
+    run_ids = {t.metadata.get("run_id") for t in results}
+    assert run1 not in run_ids
+    assert run2 in run_ids
+
+
+async def test_delete_for_runs_multiple(saver: BaseCheckpointSaver) -> None:
+    """List of run_ids removed."""
+    tid = str(uuid4())
+    run1, run2, run3 = str(uuid4()), str(uuid4()), str(uuid4())
+
+    s1 = await _put_with_run_id(saver, tid, run1)
+    s2 = await _put_with_run_id(saver, tid, run2, parent_config=s1)
+    await _put_with_run_id(saver, tid, run3, parent_config=s2)
+
+    # Pre-delete: verify all 3 runs exist
+    pre_results = []
+    async for tup in saver.alist(generate_config(tid)):
+        pre_results.append(tup)
+    pre_run_ids = {t.metadata.get("run_id") for t in pre_results}
+    assert run1 in pre_run_ids, "Pre-delete: run1 should exist"
+    assert run2 in pre_run_ids, "Pre-delete: run2 should exist"
+    assert run3 in pre_run_ids, "Pre-delete: run3 should exist"
+
+    await saver.adelete_for_runs([run1, run2])
+    results = []
+    async for tup in saver.alist(generate_config(tid)):
+        results.append(tup)
+
+    run_ids = {t.metadata.get("run_id") for t in results}
+    assert run1 not in run_ids
+    assert run2 not in run_ids
+    assert run3 in run_ids
+
+
+async def test_delete_for_runs_preserves_other_runs(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Unrelated runs untouched."""
+    tid = str(uuid4())
+    run_keep = str(uuid4())
+    run_delete = str(uuid4())
+
+    await _put_with_run_id(saver, tid, run_keep)
+    await _put_with_run_id(saver, tid, run_delete)
+
+    # Pre-delete: verify both runs exist
+    pre_results = []
+    async for tup in saver.alist(generate_config(tid)):
+        pre_results.append(tup)
+    pre_run_ids = {t.metadata.get("run_id") for t in pre_results}
+    assert run_keep in pre_run_ids, "Pre-delete: run_keep should exist"
+    assert run_delete in pre_run_ids, "Pre-delete: run_delete should exist"
+
+    await saver.adelete_for_runs([run_delete])
+    results = []
+    async for tup in saver.alist(generate_config(tid)):
+        results.append(tup)
+
+    run_ids = {t.metadata.get("run_id") for t in results}
+    assert run_keep in run_ids
+
+
+async def test_delete_for_runs_removes_writes(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Associated writes cleaned up."""
+    tid = str(uuid4())
+    run1 = str(uuid4())
+
+    stored = await _put_with_run_id(saver, tid, run1)
+    await saver.aput_writes(stored, [("ch", "val")], str(uuid4()))
+
+    # Pre-delete: verify writes exist
+    pre_tup = await saver.aget_tuple(stored)
+    assert pre_tup is not None, "Pre-delete: checkpoint should exist"
+    assert pre_tup.pending_writes is not None and len(pre_tup.pending_writes) == 1, (
+        f"Pre-delete: expected 1 write, got {len(pre_tup.pending_writes) if pre_tup.pending_writes else 0}"
+    )
+
+    await saver.adelete_for_runs([run1])
+    # The checkpoint (and its writes) should be gone
+    tup = await saver.aget_tuple(stored)
+    assert tup is None
+
+
+async def test_delete_for_runs_empty_list_noop(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Empty list no error."""
+    await saver.adelete_for_runs([])
+
+
+async def test_delete_for_runs_nonexistent_noop(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Missing run_ids no error."""
+    await saver.adelete_for_runs([str(uuid4())])
+
+
+async def test_delete_for_runs_across_namespaces(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """All namespaces cleaned."""
+    tid = str(uuid4())
+    run1 = str(uuid4())
+
+    await _put_with_run_id(saver, tid, run1, checkpoint_ns="")
+    await _put_with_run_id(saver, tid, run1, checkpoint_ns="child:1")
+
+    # Pre-delete: verify run1 present in both namespaces
+    for ns in ["", "child:1"]:
+        pre_results = []
+        async for tup in saver.alist(generate_config(tid, checkpoint_ns=ns)):
+            pre_results.append(tup)
+        pre_run_ids = {t.metadata.get("run_id") for t in pre_results}
+        assert run1 in pre_run_ids, f"Pre-delete: run1 should exist in ns='{ns}'"
+
+    await saver.adelete_for_runs([run1])
+    for ns in ["", "child:1"]:
+        results = []
+        async for tup in saver.alist(generate_config(tid, checkpoint_ns=ns)):
+            results.append(tup)
+        run_ids = {t.metadata.get("run_id") for t in results}
+        assert run1 not in run_ids
+
+
+ALL_DELETE_FOR_RUNS_TESTS = [
+    test_delete_for_runs_single,
+    test_delete_for_runs_multiple,
+    test_delete_for_runs_preserves_other_runs,
+    test_delete_for_runs_removes_writes,
+    test_delete_for_runs_empty_list_noop,
+    test_delete_for_runs_nonexistent_noop,
+    test_delete_for_runs_across_namespaces,
+]
+
+
+async def run_delete_for_runs_tests(
+    saver: BaseCheckpointSaver,
+    on_test_result: Callable[[str, str, bool, str | None], None] | None = None,
+) -> tuple[int, int, list[str]]:
+    """Run all delete_for_runs tests. Returns (passed, failed, failure_names)."""
+    passed = 0
+    failed = 0
+    failures: list[str] = []
+    for test_fn in ALL_DELETE_FOR_RUNS_TESTS:
+        try:
+            await test_fn(saver)
+            passed += 1
+            if on_test_result:
+                on_test_result("delete_for_runs", test_fn.__name__, True, None)
+        except Exception as e:
+            failed += 1
+            msg = f"{test_fn.__name__}: {e}"
+            failures.append(msg)
+            if on_test_result:
+                on_test_result(
+                    "delete_for_runs", test_fn.__name__, False, traceback.format_exc()
+                )
+    return passed, failed, failures

libs/checkpoint-conformance/langgraph/checkpoint/conformance/spec/test_delete_thread.py

@@ -0,0 +1,149 @@
+"""DELETE_THREAD capability tests — adelete_thread."""
+
+from __future__ import annotations
+
+import traceback
+from collections.abc import Callable
+from uuid import uuid4
+
+from langgraph.checkpoint.base import BaseCheckpointSaver
+
+from langgraph.checkpoint.conformance.test_utils import (
+    generate_checkpoint,
+    generate_config,
+    generate_metadata,
+)
+
+
+async def test_delete_thread_removes_checkpoints(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """All checkpoints gone after delete."""
+    tid = str(uuid4())
+    parent_cfg = None
+    for i in range(3):
+        config = generate_config(tid)
+        if parent_cfg:
+            config["configurable"]["checkpoint_id"] = parent_cfg["configurable"][
+                "checkpoint_id"
+            ]
+        cp = generate_checkpoint()
+        parent_cfg = await saver.aput(config, cp, generate_metadata(step=i), {})
+
+    # Pre-delete: verify data exists
+    assert await saver.aget_tuple(generate_config(tid)) is not None, (
+        "Pre-delete: checkpoint should exist"
+    )
+
+    await saver.adelete_thread(tid)
+
+    tup = await saver.aget_tuple(generate_config(tid))
+    assert tup is None
+
+    results = []
+    async for t in saver.alist(generate_config(tid)):
+        results.append(t)
+    assert len(results) == 0
+
+
+async def test_delete_thread_removes_writes(saver: BaseCheckpointSaver) -> None:
+    """Pending writes gone after delete."""
+    tid = str(uuid4())
+    config = generate_config(tid)
+    cp = generate_checkpoint()
+    stored = await saver.aput(config, cp, generate_metadata(), {})
+    await saver.aput_writes(stored, [("ch", "val")], str(uuid4()))
+
+    # Pre-delete: verify writes exist
+    pre_tup = await saver.aget_tuple(generate_config(tid))
+    assert pre_tup is not None, "Pre-delete: checkpoint should exist"
+    assert pre_tup.pending_writes is not None and len(pre_tup.pending_writes) == 1, (
+        f"Pre-delete: expected 1 write, got {len(pre_tup.pending_writes) if pre_tup.pending_writes else 0}"
+    )
+
+    await saver.adelete_thread(tid)
+
+    tup = await saver.aget_tuple(generate_config(tid))
+    assert tup is None
+
+
+async def test_delete_thread_removes_all_namespaces(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Root + child namespaces both removed."""
+    tid = str(uuid4())
+
+    for ns in ["", "child:1"]:
+        cfg = generate_config(tid, checkpoint_ns=ns)
+        cp = generate_checkpoint()
+        await saver.aput(cfg, cp, generate_metadata(), {})
+
+    # Pre-delete: verify each namespace has data
+    for ns in ["", "child:1"]:
+        pre = await saver.aget_tuple(generate_config(tid, checkpoint_ns=ns))
+        assert pre is not None, f"Pre-delete: namespace '{ns}' should have data"
+
+    await saver.adelete_thread(tid)
+
+    for ns in ["", "child:1"]:
+        tup = await saver.aget_tuple(generate_config(tid, checkpoint_ns=ns))
+        assert tup is None
+
+
+async def test_delete_thread_preserves_other_threads(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Other threads untouched."""
+    tid1, tid2 = str(uuid4()), str(uuid4())
+
+    for tid in (tid1, tid2):
+        cfg = generate_config(tid)
+        cp = generate_checkpoint()
+        await saver.aput(cfg, cp, generate_metadata(), {})
+
+    await saver.adelete_thread(tid1)
+
+    assert await saver.aget_tuple(generate_config(tid1)) is None
+    assert await saver.aget_tuple(generate_config(tid2)) is not None
+
+
+async def test_delete_thread_nonexistent_noop(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """No error for missing thread."""
+    # Should not raise
+    await saver.adelete_thread(str(uuid4()))
+
+
+ALL_DELETE_THREAD_TESTS = [
+    test_delete_thread_removes_checkpoints,
+    test_delete_thread_removes_writes,
+    test_delete_thread_removes_all_namespaces,
+    test_delete_thread_preserves_other_threads,
+    test_delete_thread_nonexistent_noop,
+]
+
+
+async def run_delete_thread_tests(
+    saver: BaseCheckpointSaver,
+    on_test_result: Callable[[str, str, bool, str | None], None] | None = None,
+) -> tuple[int, int, list[str]]:
+    """Run all delete_thread tests. Returns (passed, failed, failure_names)."""
+    passed = 0
+    failed = 0
+    failures: list[str] = []
+    for test_fn in ALL_DELETE_THREAD_TESTS:
+        try:
+            await test_fn(saver)
+            passed += 1
+            if on_test_result:
+                on_test_result("delete_thread", test_fn.__name__, True, None)
+        except Exception as e:
+            failed += 1
+            msg = f"{test_fn.__name__}: {e}"
+            failures.append(msg)
+            if on_test_result:
+                on_test_result(
+                    "delete_thread", test_fn.__name__, False, traceback.format_exc()
+                )
+    return passed, failed, failures

libs/checkpoint-conformance/langgraph/checkpoint/conformance/spec/test_get_tuple.py

@@ -0,0 +1,253 @@
+"""GET_TUPLE capability tests — aget_tuple retrieval."""
+
+from __future__ import annotations
+
+import traceback
+from collections.abc import Callable
+from uuid import uuid4
+
+from langgraph.checkpoint.base import BaseCheckpointSaver
+
+from langgraph.checkpoint.conformance.test_utils import (
+    generate_checkpoint,
+    generate_config,
+    generate_metadata,
+)
+
+
+async def test_get_tuple_nonexistent_returns_none(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Missing thread returns None."""
+    config = generate_config(str(uuid4()))
+    tup = await saver.aget_tuple(config)
+    assert tup is None
+
+
+async def test_get_tuple_latest_when_no_checkpoint_id(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Returns newest checkpoint when no checkpoint_id in config."""
+    tid = str(uuid4())
+    ids = []
+    parent_cfg = None
+    for i in range(3):
+        config = generate_config(tid)
+        if parent_cfg:
+            config["configurable"]["checkpoint_id"] = parent_cfg["configurable"][
+                "checkpoint_id"
+            ]
+        cp = generate_checkpoint()
+        parent_cfg = await saver.aput(config, cp, generate_metadata(step=i), {})
+        ids.append(cp["id"])
+
+    # Get without checkpoint_id — should return the latest
+    tup = await saver.aget_tuple(generate_config(tid))
+    assert tup is not None
+    assert tup.checkpoint["id"] == ids[-1]
+    assert tup.metadata["step"] == 2, (
+        f"Expected latest step=2, got {tup.metadata['step']}"
+    )
+
+
+async def test_get_tuple_specific_checkpoint_id(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Returns exact match when checkpoint_id specified."""
+    tid = str(uuid4())
+
+    config1 = generate_config(tid)
+    cp1 = generate_checkpoint()
+    stored1 = await saver.aput(config1, cp1, generate_metadata(step=0), {})
+
+    config2 = generate_config(tid)
+    config2["configurable"]["checkpoint_id"] = stored1["configurable"]["checkpoint_id"]
+    cp2 = generate_checkpoint()
+    await saver.aput(config2, cp2, generate_metadata(step=1), {})
+
+    # Fetch the first one specifically
+    tup = await saver.aget_tuple(stored1)
+    assert tup is not None
+    assert tup.checkpoint["id"] == cp1["id"]
+
+
+async def test_get_tuple_config_structure(saver: BaseCheckpointSaver) -> None:
+    """tuple.config has thread_id, checkpoint_ns, checkpoint_id."""
+    tid = str(uuid4())
+    config = generate_config(tid)
+    cp = generate_checkpoint()
+    stored = await saver.aput(config, cp, generate_metadata(), {})
+
+    tup = await saver.aget_tuple(stored)
+    assert tup is not None
+    conf = tup.config["configurable"]
+    assert conf["thread_id"] == tid
+    assert conf.get("checkpoint_ns", "") == "", (
+        f"Expected checkpoint_ns='', got {conf.get('checkpoint_ns')!r}"
+    )
+    assert conf["checkpoint_id"] == cp["id"]
+
+
+async def test_get_tuple_checkpoint_fields(saver: BaseCheckpointSaver) -> None:
+    """All Checkpoint fields present."""
+    tid = str(uuid4())
+    config = generate_config(tid)
+    cp = generate_checkpoint(channel_values={"k": "v"})
+    cp["channel_versions"] = {"k": 1}
+    stored = await saver.aput(config, cp, generate_metadata(), {"k": 1})
+
+    tup = await saver.aget_tuple(stored)
+    assert tup is not None
+    c = tup.checkpoint
+    assert c["id"] == cp["id"], f"id mismatch: {c['id']!r} != {cp['id']!r}"
+    assert c["v"] == 1, f"Expected v=1, got {c['v']!r}"
+    assert "ts" in c and c["ts"], "ts should be non-empty"
+    assert c["channel_values"] == {"k": "v"}, f"channel_values: {c['channel_values']!r}"
+    assert "channel_versions" in c
+    assert "versions_seen" in c
+
+
+async def test_get_tuple_metadata(saver: BaseCheckpointSaver) -> None:
+    """metadata populated correctly."""
+    tid = str(uuid4())
+    config = generate_config(tid)
+    cp = generate_checkpoint()
+    md = generate_metadata(source="input", step=-1)
+    stored = await saver.aput(config, cp, md, {})
+
+    tup = await saver.aget_tuple(stored)
+    assert tup is not None
+    assert tup.metadata["source"] == "input"
+    assert tup.metadata["step"] == -1
+
+
+async def test_get_tuple_parent_config(saver: BaseCheckpointSaver) -> None:
+    """parent_config when parent exists, None otherwise."""
+    tid = str(uuid4())
+
+    # First checkpoint — no parent
+    config1 = generate_config(tid)
+    cp1 = generate_checkpoint()
+    stored1 = await saver.aput(config1, cp1, generate_metadata(step=0), {})
+
+    tup1 = await saver.aget_tuple(stored1)
+    assert tup1 is not None
+    assert tup1.parent_config is None
+
+    # Second checkpoint — has parent
+    config2 = generate_config(tid)
+    config2["configurable"]["checkpoint_id"] = stored1["configurable"]["checkpoint_id"]
+    cp2 = generate_checkpoint()
+    stored2 = await saver.aput(config2, cp2, generate_metadata(step=1), {})
+
+    tup2 = await saver.aget_tuple(stored2)
+    assert tup2 is not None
+    assert tup2.parent_config is not None
+    assert (
+        tup2.parent_config["configurable"]["checkpoint_id"]
+        == stored1["configurable"]["checkpoint_id"]
+    )
+
+
+async def test_get_tuple_pending_writes(saver: BaseCheckpointSaver) -> None:
+    """pending_writes from put_writes visible."""
+    tid = str(uuid4())
+    config = generate_config(tid)
+    cp = generate_checkpoint()
+    stored = await saver.aput(config, cp, generate_metadata(), {})
+
+    task_id = str(uuid4())
+    await saver.aput_writes(stored, [("ch", "val")], task_id)
+
+    tup = await saver.aget_tuple(stored)
+    assert tup is not None
+    assert tup.pending_writes is not None
+    assert len(tup.pending_writes) == 1, (
+        f"Expected 1 write, got {len(tup.pending_writes)}"
+    )
+    assert tup.pending_writes[0][0] == task_id, (
+        f"task_id mismatch: {tup.pending_writes[0][0]!r}"
+    )
+    assert tup.pending_writes[0][1] == "ch", (
+        f"channel mismatch: {tup.pending_writes[0][1]!r}"
+    )
+    assert tup.pending_writes[0][2] == "val", (
+        f"value mismatch: {tup.pending_writes[0][2]!r}"
+    )
+
+
+async def test_get_tuple_respects_namespace(saver: BaseCheckpointSaver) -> None:
+    """checkpoint_ns filtering."""
+    tid = str(uuid4())
+
+    cfg_root = generate_config(tid, checkpoint_ns="")
+    cp_root = generate_checkpoint()
+    stored_root = await saver.aput(cfg_root, cp_root, generate_metadata(), {})
+
+    cfg_child = generate_config(tid, checkpoint_ns="child:1")
+    cp_child = generate_checkpoint()
+    stored_child = await saver.aput(cfg_child, cp_child, generate_metadata(), {})
+
+    tup_root = await saver.aget_tuple(stored_root)
+    assert tup_root is not None
+    assert tup_root.checkpoint["id"] == cp_root["id"]
+
+    tup_child = await saver.aget_tuple(stored_child)
+    assert tup_child is not None
+    assert tup_child.checkpoint["id"] == cp_child["id"]
+
+
+async def test_get_tuple_nonexistent_checkpoint_id(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Specific but missing checkpoint_id returns None."""
+    tid = str(uuid4())
+    nonexistent_id = str(uuid4())
+    # Put one checkpoint so the thread exists
+    config = generate_config(tid)
+    cp = generate_checkpoint()
+    await saver.aput(config, cp, generate_metadata(), {})
+
+    # Ask for a non-existent checkpoint_id
+    bad_cfg = generate_config(tid, checkpoint_id=nonexistent_id)
+    tup = await saver.aget_tuple(bad_cfg)
+    assert tup is None
+
+
+ALL_GET_TUPLE_TESTS = [
+    test_get_tuple_nonexistent_returns_none,
+    test_get_tuple_latest_when_no_checkpoint_id,
+    test_get_tuple_specific_checkpoint_id,
+    test_get_tuple_config_structure,
+    test_get_tuple_checkpoint_fields,
+    test_get_tuple_metadata,
+    test_get_tuple_parent_config,
+    test_get_tuple_pending_writes,
+    test_get_tuple_respects_namespace,
+    test_get_tuple_nonexistent_checkpoint_id,
+]
+
+
+async def run_get_tuple_tests(
+    saver: BaseCheckpointSaver,
+    on_test_result: Callable[[str, str, bool, str | None], None] | None = None,
+) -> tuple[int, int, list[str]]:
+    """Run all get_tuple tests. Returns (passed, failed, failure_names)."""
+    passed = 0
+    failed = 0
+    failures: list[str] = []
+    for test_fn in ALL_GET_TUPLE_TESTS:
+        try:
+            await test_fn(saver)
+            passed += 1
+            if on_test_result:
+                on_test_result("get_tuple", test_fn.__name__, True, None)
+        except Exception as e:
+            failed += 1
+            msg = f"{test_fn.__name__}: {e}"
+            failures.append(msg)
+            if on_test_result:
+                on_test_result(
+                    "get_tuple", test_fn.__name__, False, traceback.format_exc()
+                )
+    return passed, failed, failures

libs/checkpoint-conformance/langgraph/checkpoint/conformance/spec/test_list.py

@@ -0,0 +1,414 @@
+"""LIST capability tests — alist with various filters."""
+
+from __future__ import annotations
+
+import traceback
+from collections.abc import Callable
+from uuid import uuid4
+
+from langgraph.checkpoint.base import BaseCheckpointSaver
+
+from langgraph.checkpoint.conformance.test_utils import (
+    generate_checkpoint,
+    generate_config,
+    generate_metadata,
+)
+
+
+async def _setup_list_data(saver: BaseCheckpointSaver) -> dict:
+    """Populate saver with test data for list tests. Returns lookup info."""
+    tid = str(uuid4())
+    ids = []
+    parent_cfg = None
+    for i in range(4):
+        config = generate_config(tid)
+        if parent_cfg:
+            config["configurable"]["checkpoint_id"] = parent_cfg["configurable"][
+                "checkpoint_id"
+            ]
+        cp = generate_checkpoint()
+        source = "input" if i % 2 == 0 else "loop"
+        md = generate_metadata(source=source, step=i)
+        parent_cfg = await saver.aput(config, cp, md, {})
+        ids.append(cp["id"])
+
+    return {
+        "thread_id": tid,
+        "checkpoint_ids": ids,
+        "latest_config": parent_cfg,
+    }
+
+
+async def test_list_all(saver: BaseCheckpointSaver) -> None:
+    """No filters returns all checkpoints for the thread."""
+    data = await _setup_list_data(saver)
+    tid = data["thread_id"]
+
+    results = []
+    async for tup in saver.alist(generate_config(tid)):
+        results.append(tup)
+
+    assert len(results) == 4
+
+
+async def test_list_by_thread(saver: BaseCheckpointSaver) -> None:
+    """Filter by thread_id — other threads not returned."""
+    data = await _setup_list_data(saver)
+
+    # List for a non-existent thread
+    results = []
+    async for tup in saver.alist(generate_config(str(uuid4()))):
+        results.append(tup)
+    assert len(results) == 0
+
+    # List for actual thread
+    results = []
+    async for tup in saver.alist(generate_config(data["thread_id"])):
+        results.append(tup)
+    assert len(results) == 4
+
+
+async def test_list_by_namespace(saver: BaseCheckpointSaver) -> None:
+    """Filter by checkpoint_ns."""
+    tid = str(uuid4())
+
+    # Root namespace
+    cfg1 = generate_config(tid, checkpoint_ns="")
+    cp1 = generate_checkpoint()
+    await saver.aput(cfg1, cp1, generate_metadata(), {})
+
+    # Child namespace
+    cfg2 = generate_config(tid, checkpoint_ns="child:1")
+    cp2 = generate_checkpoint()
+    await saver.aput(cfg2, cp2, generate_metadata(), {})
+
+    root_results = []
+    async for tup in saver.alist(generate_config(tid, checkpoint_ns="")):
+        root_results.append(tup)
+    assert len(root_results) == 1
+
+    child_results = []
+    async for tup in saver.alist(generate_config(tid, checkpoint_ns="child:1")):
+        child_results.append(tup)
+    assert len(child_results) == 1
+
+
+async def test_list_ordering(saver: BaseCheckpointSaver) -> None:
+    """Newest first (descending checkpoint_id)."""
+    data = await _setup_list_data(saver)
+    ids = data["checkpoint_ids"]
+
+    results = []
+    async for tup in saver.alist(generate_config(data["thread_id"])):
+        results.append(tup.checkpoint["id"])
+
+    # Should be in reverse order (newest first)
+    assert results == list(reversed(ids))
+
+
+async def test_list_metadata_filter_single_key(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """filter={'source': 'input'} returns only input checkpoints."""
+    data = await _setup_list_data(saver)
+
+    results = []
+    async for tup in saver.alist(
+        generate_config(data["thread_id"]),
+        filter={"source": "input"},
+    ):
+        results.append(tup)
+
+    assert len(results) == 2, (
+        f"Expected 2 'input' checkpoints (steps 0,2), got {len(results)}"
+    )
+    for tup in results:
+        assert tup.metadata["source"] == "input"
+
+
+async def test_list_metadata_filter_step(saver: BaseCheckpointSaver) -> None:
+    """filter={'step': 1} returns matching checkpoints."""
+    data = await _setup_list_data(saver)
+
+    results = []
+    async for tup in saver.alist(
+        generate_config(data["thread_id"]),
+        filter={"step": 1},
+    ):
+        results.append(tup)
+
+    assert len(results) == 1
+    assert results[0].metadata["step"] == 1
+
+
+async def test_list_before(saver: BaseCheckpointSaver) -> None:
+    """Pagination cursor — only checkpoints before the given one."""
+    data = await _setup_list_data(saver)
+    ids = data["checkpoint_ids"]
+
+    # Use the 3rd checkpoint as the 'before' cursor (index 2)
+    before_cfg = generate_config(data["thread_id"], checkpoint_id=ids[2])
+    results = []
+    async for tup in saver.alist(
+        generate_config(data["thread_id"]),
+        before=before_cfg,
+    ):
+        results.append(tup)
+
+    # Should only include checkpoints before ids[2]
+    result_ids = [t.checkpoint["id"] for t in results]
+    assert ids[2] not in result_ids
+    assert ids[3] not in result_ids
+    assert set(result_ids) == {ids[0], ids[1]}, (
+        f"Expected {{ids[0], ids[1]}}, got {set(result_ids)}"
+    )
+
+
+async def test_list_limit(saver: BaseCheckpointSaver) -> None:
+    """limit=1, limit=N."""
+    data = await _setup_list_data(saver)
+
+    results = []
+    async for tup in saver.alist(generate_config(data["thread_id"]), limit=1):
+        results.append(tup)
+    assert len(results) == 1
+
+    results = []
+    async for tup in saver.alist(generate_config(data["thread_id"]), limit=2):
+        results.append(tup)
+    assert len(results) == 2
+
+
+async def test_list_limit_plus_before(saver: BaseCheckpointSaver) -> None:
+    """Pagination with limit."""
+    data = await _setup_list_data(saver)
+    ids = data["checkpoint_ids"]
+
+    before_cfg = generate_config(data["thread_id"], checkpoint_id=ids[3])
+    results = []
+    async for tup in saver.alist(
+        generate_config(data["thread_id"]),
+        before=before_cfg,
+        limit=1,
+    ):
+        results.append(tup)
+
+    assert len(results) == 1
+    assert results[0].checkpoint["id"] == ids[2]
+
+
+async def test_list_combined_thread_and_filter(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """thread_id + metadata filter combined."""
+    data = await _setup_list_data(saver)
+
+    results = []
+    async for tup in saver.alist(
+        generate_config(data["thread_id"]),
+        filter={"source": "loop"},
+    ):
+        results.append(tup)
+
+    assert len(results) == 2, (
+        f"Expected 2 'loop' checkpoints (steps 1,3), got {len(results)}"
+    )
+    for tup in results:
+        assert tup.metadata["source"] == "loop"
+
+
+async def test_list_empty_result(saver: BaseCheckpointSaver) -> None:
+    """No matches returns empty."""
+    results = []
+    async for tup in saver.alist(
+        generate_config(str(uuid4())),
+        filter={"source": "nonexistent"},
+    ):
+        results.append(tup)
+    assert len(results) == 0
+
+
+async def test_list_includes_pending_writes(saver: BaseCheckpointSaver) -> None:
+    """pending_writes in listed tuples."""
+    tid = str(uuid4())
+    config = generate_config(tid)
+    cp = generate_checkpoint()
+    stored = await saver.aput(config, cp, generate_metadata(), {})
+
+    await saver.aput_writes(stored, [("ch", "val")], str(uuid4()))
+
+    results = []
+    async for tup in saver.alist(generate_config(tid)):
+        results.append(tup)
+
+    assert len(results) == 1
+    assert results[0].pending_writes is not None
+    assert len(results[0].pending_writes) == 1, (
+        f"Expected 1 write, got {len(results[0].pending_writes)}"
+    )
+    assert results[0].pending_writes[0][1] == "ch", (
+        f"channel mismatch: {results[0].pending_writes[0][1]!r}"
+    )
+    assert results[0].pending_writes[0][2] == "val", (
+        f"value mismatch: {results[0].pending_writes[0][2]!r}"
+    )
+
+
+async def test_list_multiple_namespaces(saver: BaseCheckpointSaver) -> None:
+    """Root namespace checkpoint listed correctly."""
+    tid = str(uuid4())
+
+    for ns in ["", "child:1", "child:2"]:
+        cfg = generate_config(tid, checkpoint_ns=ns)
+        cp = generate_checkpoint()
+        await saver.aput(cfg, cp, generate_metadata(), {})
+
+    # List with root namespace filter — should return exactly the root checkpoint
+    results = []
+    async for tup in saver.alist(generate_config(tid, checkpoint_ns="")):
+        results.append(tup)
+    assert len(results) == 1, f"Expected 1 root checkpoint, got {len(results)}"
+
+
+async def test_list_metadata_filter_multiple_keys(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """filter with multiple keys — all must match."""
+    tid = str(uuid4())
+
+    # Create checkpoints with different metadata combos
+    for source, step in [("input", 1), ("loop", 1), ("input", 2)]:
+        cfg = generate_config(tid)
+        cp = generate_checkpoint()
+        await saver.aput(cfg, cp, generate_metadata(source=source, step=step), {})
+
+    results = []
+    async for tup in saver.alist(
+        generate_config(tid),
+        filter={"source": "input", "step": 2},
+    ):
+        results.append(tup)
+
+    assert len(results) == 1, (
+        f"Expected 1 match for source=input+step=2, got {len(results)}"
+    )
+    assert results[0].metadata["source"] == "input"
+    assert results[0].metadata["step"] == 2
+
+
+async def test_list_metadata_filter_no_match(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Multi-key filter that matches nothing returns empty."""
+    data = await _setup_list_data(saver)
+
+    results = []
+    async for tup in saver.alist(
+        generate_config(data["thread_id"]),
+        filter={"source": "update", "step": 99},
+    ):
+        results.append(tup)
+
+    assert len(results) == 0
+
+
+async def test_list_metadata_custom_keys(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Custom (non-standard) metadata keys are filterable."""
+    tid = str(uuid4())
+
+    cfg = generate_config(tid)
+    cp = generate_checkpoint()
+    await saver.aput(cfg, cp, generate_metadata(score=42, run_id="run-abc"), {})
+
+    cfg2 = generate_config(tid)
+    cp2 = generate_checkpoint()
+    await saver.aput(cfg2, cp2, generate_metadata(score=99, run_id="run-xyz"), {})
+
+    # Filter by custom key
+    results = []
+    async for tup in saver.alist(
+        generate_config(tid),
+        filter={"score": 42},
+    ):
+        results.append(tup)
+
+    assert len(results) == 1
+    assert results[0].metadata["score"] == 42
+    assert results[0].metadata["run_id"] == "run-abc"
+
+
+async def test_list_global_search(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """alist(None, filter=...) searches across all threads."""
+    tid1, tid2 = str(uuid4()), str(uuid4())
+
+    # Use a unique marker so we don't collide with other tests' data
+    marker = str(uuid4())
+
+    cfg1 = generate_config(tid1)
+    cp1 = generate_checkpoint()
+    await saver.aput(cfg1, cp1, generate_metadata(source="input", marker=marker), {})
+
+    cfg2 = generate_config(tid2)
+    cp2 = generate_checkpoint()
+    await saver.aput(cfg2, cp2, generate_metadata(source="loop", marker=marker), {})
+
+    # Search across all threads with filter
+    results = []
+    async for tup in saver.alist(None, filter={"source": "input", "marker": marker}):
+        results.append(tup)
+    assert len(results) == 1
+    assert results[0].config["configurable"]["thread_id"] == tid1
+
+    # Search with marker only — should find both
+    results = []
+    async for tup in saver.alist(None, filter={"marker": marker}):
+        results.append(tup)
+    assert len(results) == 2
+
+
+ALL_LIST_TESTS = [
+    test_list_all,
+    test_list_by_thread,
+    test_list_by_namespace,
+    test_list_ordering,
+    test_list_metadata_filter_single_key,
+    test_list_metadata_filter_step,
+    test_list_metadata_filter_multiple_keys,
+    test_list_metadata_filter_no_match,
+    test_list_metadata_custom_keys,
+    test_list_global_search,
+    test_list_before,
+    test_list_limit,
+    test_list_limit_plus_before,
+    test_list_combined_thread_and_filter,
+    test_list_empty_result,
+    test_list_includes_pending_writes,
+    test_list_multiple_namespaces,
+]
+
+
+async def run_list_tests(
+    saver: BaseCheckpointSaver,
+    on_test_result: Callable[[str, str, bool, str | None], None] | None = None,
+) -> tuple[int, int, list[str]]:
+    """Run all list tests. Returns (passed, failed, failure_names)."""
+    passed = 0
+    failed = 0
+    failures: list[str] = []
+    for test_fn in ALL_LIST_TESTS:
+        try:
+            await test_fn(saver)
+            passed += 1
+            if on_test_result:
+                on_test_result("list", test_fn.__name__, True, None)
+        except Exception as e:
+            failed += 1
+            msg = f"{test_fn.__name__}: {e}"
+            failures.append(msg)
+            if on_test_result:
+                on_test_result("list", test_fn.__name__, False, traceback.format_exc())
+    return passed, failed, failures

libs/checkpoint-conformance/langgraph/checkpoint/conformance/spec/test_prune.py

@@ -0,0 +1,217 @@
+"""PRUNE capability tests — aprune(strategy)."""
+
+from __future__ import annotations
+
+import traceback
+from collections.abc import Callable
+from uuid import uuid4
+
+from langgraph.checkpoint.base import BaseCheckpointSaver
+
+from langgraph.checkpoint.conformance.test_utils import (
+    generate_checkpoint,
+    generate_config,
+    generate_metadata,
+)
+
+
+async def _setup_thread(saver: BaseCheckpointSaver, tid: str, n: int = 3) -> list[dict]:
+    """Create n checkpoints on tid. Returns stored configs."""
+    stored = []
+    parent_cfg = None
+    for i in range(n):
+        config = generate_config(tid)
+        if parent_cfg:
+            config["configurable"]["checkpoint_id"] = parent_cfg["configurable"][
+                "checkpoint_id"
+            ]
+        cp = generate_checkpoint()
+        parent_cfg = await saver.aput(config, cp, generate_metadata(step=i), {})
+        stored.append(parent_cfg)
+    return stored
+
+
+async def test_prune_keep_latest_single_thread(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Only latest checkpoint survives."""
+    tid = str(uuid4())
+    configs = await _setup_thread(saver, tid, n=4)
+
+    await saver.aprune([tid], strategy="keep_latest")
+    results = []
+    async for tup in saver.alist(generate_config(tid)):
+        results.append(tup)
+
+    assert len(results) == 1
+    assert (
+        results[0].config["configurable"]["checkpoint_id"]
+        == configs[-1]["configurable"]["checkpoint_id"]
+    )
+
+
+async def test_prune_keep_latest_multiple_threads(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Each thread keeps its latest."""
+    tid1, tid2 = str(uuid4()), str(uuid4())
+    c1 = await _setup_thread(saver, tid1, n=3)
+    c2 = await _setup_thread(saver, tid2, n=2)
+
+    await saver.aprune([tid1, tid2], strategy="keep_latest")
+    for tid, expected_last in [(tid1, c1[-1]), (tid2, c2[-1])]:
+        results = []
+        async for tup in saver.alist(generate_config(tid)):
+            results.append(tup)
+        assert len(results) == 1
+        assert (
+            results[0].config["configurable"]["checkpoint_id"]
+            == expected_last["configurable"]["checkpoint_id"]
+        )
+
+
+async def test_prune_keep_latest_across_namespaces(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Latest per namespace kept."""
+    tid = str(uuid4())
+
+    # Root namespace: 3 checkpoints
+    parent = None
+    for i in range(3):
+        cfg = generate_config(tid, checkpoint_ns="")
+        if parent:
+            cfg["configurable"]["checkpoint_id"] = parent["configurable"][
+                "checkpoint_id"
+            ]
+        cp = generate_checkpoint()
+        parent = await saver.aput(cfg, cp, generate_metadata(step=i), {})
+    root_latest = parent
+
+    # Child namespace: 2 checkpoints
+    parent = None
+    for i in range(2):
+        cfg = generate_config(tid, checkpoint_ns="child:1")
+        if parent:
+            cfg["configurable"]["checkpoint_id"] = parent["configurable"][
+                "checkpoint_id"
+            ]
+        cp = generate_checkpoint()
+        parent = await saver.aput(cfg, cp, generate_metadata(step=i), {})
+    child_latest = parent
+
+    assert root_latest is not None
+    assert child_latest is not None
+    await saver.aprune([tid], strategy="keep_latest")
+    for ns, expected in [("", root_latest), ("child:1", child_latest)]:
+        results = []
+        async for tup in saver.alist(generate_config(tid, checkpoint_ns=ns)):
+            results.append(tup)
+        assert len(results) == 1
+        assert (
+            results[0].config["configurable"]["checkpoint_id"]
+            == expected["configurable"]["checkpoint_id"]
+        )
+
+
+async def test_prune_keep_latest_preserves_writes(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Latest checkpoint's writes kept."""
+    tid = str(uuid4())
+    configs = await _setup_thread(saver, tid, n=3)
+
+    # Add writes to the latest
+    await saver.aput_writes(configs[-1], [("ch", "val")], str(uuid4()))
+
+    await saver.aprune([tid], strategy="keep_latest")
+    tup = await saver.aget_tuple(generate_config(tid))
+    assert tup is not None
+    assert tup.pending_writes is not None
+    assert len(tup.pending_writes) == 1, (
+        f"Expected 1 write, got {len(tup.pending_writes)}"
+    )
+    assert tup.pending_writes[0][1] == "ch", (
+        f"channel mismatch: {tup.pending_writes[0][1]!r}"
+    )
+    assert tup.pending_writes[0][2] == "val", (
+        f"value mismatch: {tup.pending_writes[0][2]!r}"
+    )
+
+
+async def test_prune_delete_all(saver: BaseCheckpointSaver) -> None:
+    """delete_all strategy removes everything."""
+    tid = str(uuid4())
+    await _setup_thread(saver, tid, n=3)
+
+    await saver.aprune([tid], strategy="delete")
+    results = []
+    async for tup in saver.alist(generate_config(tid)):
+        results.append(tup)
+    assert len(results) == 0
+
+
+async def test_prune_preserves_other_threads(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Unlisted threads untouched."""
+    tid1, tid2 = str(uuid4()), str(uuid4())
+    await _setup_thread(saver, tid1, n=3)
+    await _setup_thread(saver, tid2, n=2)
+
+    # Snapshot tid2 before prune
+    pre_ids = []
+    async for tup in saver.alist(generate_config(tid2)):
+        pre_ids.append(tup.checkpoint["id"])
+
+    await saver.aprune([tid1], strategy="keep_latest")
+    # tid2 should be fully intact — same checkpoint IDs
+    post_ids = []
+    async for tup in saver.alist(generate_config(tid2)):
+        post_ids.append(tup.checkpoint["id"])
+    assert post_ids == pre_ids, f"tid2 changed: {pre_ids} -> {post_ids}"
+
+
+async def test_prune_empty_list_noop(saver: BaseCheckpointSaver) -> None:
+    """Empty thread_ids no error."""
+    await saver.aprune([], strategy="keep_latest")
+
+
+async def test_prune_nonexistent_noop(saver: BaseCheckpointSaver) -> None:
+    """Missing threads no error."""
+    await saver.aprune([str(uuid4())], strategy="keep_latest")
+
+
+ALL_PRUNE_TESTS = [
+    test_prune_keep_latest_single_thread,
+    test_prune_keep_latest_multiple_threads,
+    test_prune_keep_latest_across_namespaces,
+    test_prune_keep_latest_preserves_writes,
+    test_prune_delete_all,
+    test_prune_preserves_other_threads,
+    test_prune_empty_list_noop,
+    test_prune_nonexistent_noop,
+]
+
+
+async def run_prune_tests(
+    saver: BaseCheckpointSaver,
+    on_test_result: Callable[[str, str, bool, str | None], None] | None = None,
+) -> tuple[int, int, list[str]]:
+    """Run all prune tests. Returns (passed, failed, failure_names)."""
+    passed = 0
+    failed = 0
+    failures: list[str] = []
+    for test_fn in ALL_PRUNE_TESTS:
+        try:
+            await test_fn(saver)
+            passed += 1
+            if on_test_result:
+                on_test_result("prune", test_fn.__name__, True, None)
+        except Exception as e:
+            failed += 1
+            msg = f"{test_fn.__name__}: {e}"
+            failures.append(msg)
+            if on_test_result:
+                on_test_result("prune", test_fn.__name__, False, traceback.format_exc())
+    return passed, failed, failures

libs/checkpoint-conformance/langgraph/checkpoint/conformance/spec/test_put.py

@@ -0,0 +1,411 @@
+"""PUT capability tests — aput + aget_tuple round-trip."""
+
+from __future__ import annotations
+
+import traceback
+from collections.abc import Callable
+from typing import Any
+from uuid import uuid4
+
+from langgraph.checkpoint.base import (
+    BaseCheckpointSaver,
+    ChannelVersions,
+)
+
+from langgraph.checkpoint.conformance.test_utils import (
+    generate_checkpoint,
+    generate_config,
+    generate_metadata,
+)
+
+
+async def test_put_returns_config(saver: BaseCheckpointSaver) -> None:
+    """aput returns a RunnableConfig with thread_id, checkpoint_ns, checkpoint_id."""
+    config = generate_config()
+    cp = generate_checkpoint(channel_values={"k": "v"})
+    cp["channel_versions"] = {"k": 1}
+    md = generate_metadata()
+
+    result = await saver.aput(config, cp, md, {"k": 1})
+
+    assert "configurable" in result
+    conf = result["configurable"]
+    assert "thread_id" in conf
+    assert "checkpoint_ns" in conf
+    assert "checkpoint_id" in conf
+    assert conf["checkpoint_id"] == cp["id"]
+
+
+async def test_put_roundtrip(saver: BaseCheckpointSaver) -> None:
+    """put then get_tuple returns identical checkpoint."""
+    config = generate_config()
+    cp = generate_checkpoint(channel_values={"msg": "hello"})
+    cp["channel_versions"] = {"msg": 1}
+    md = generate_metadata(source="input", step=-1)
+
+    stored_config = await saver.aput(config, cp, md, {"msg": 1})
+
+    tup = await saver.aget_tuple(stored_config)
+    assert tup is not None
+    assert tup.checkpoint["id"] == cp["id"]
+    assert tup.checkpoint["channel_values"] == {"msg": "hello"}
+
+
+async def test_put_preserves_channel_values(saver: BaseCheckpointSaver) -> None:
+    """Various types (str, int, list, dict, bytes, None) round-trip correctly."""
+    values: dict[str, Any] = {
+        "str_val": "hello",
+        "int_val": 42,
+        "list_val": [1, 2, 3],
+        "dict_val": {"nested": True},
+    }
+    config = generate_config()
+    cp = generate_checkpoint(channel_values=values)
+    versions: ChannelVersions = {k: 1 for k in values}
+    cp["channel_versions"] = versions
+    md = generate_metadata()
+
+    stored = await saver.aput(config, cp, md, versions)
+    tup = await saver.aget_tuple(stored)
+    assert tup is not None
+    for k, v in values.items():
+        assert tup.checkpoint["channel_values"].get(k) == v, (
+            f"channel_values[{k}]: expected {v!r}, got {tup.checkpoint['channel_values'].get(k)!r}"
+        )
+
+
+async def test_put_preserves_channel_versions(saver: BaseCheckpointSaver) -> None:
+    """ChannelVersions round-trip correctly."""
+    versions: ChannelVersions = {"a": 1, "b": 2}
+    config = generate_config()
+    cp = generate_checkpoint(
+        channel_values={"a": "x", "b": "y"}, channel_versions=versions
+    )
+    md = generate_metadata()
+
+    stored = await saver.aput(config, cp, md, versions)
+    tup = await saver.aget_tuple(stored)
+    assert tup is not None
+    # Compare version values — checkpointers may convert int to str
+    for k, expected in versions.items():
+        actual = tup.checkpoint["channel_versions"].get(k)
+        assert actual is not None, f"channel_versions[{k}] missing"
+        assert str(actual).split(".")[0] == str(expected).split(".")[0], (
+            f"channel_versions[{k}]: expected {expected!r}, got {actual!r}"
+        )
+
+
+async def test_put_preserves_versions_seen(saver: BaseCheckpointSaver) -> None:
+    """versions_seen dict round-trips."""
+    vs: dict[str, ChannelVersions] = {"node1": {"ch": 1}, "node2": {"ch": 2}}
+    config = generate_config()
+    cp = generate_checkpoint(versions_seen=vs)
+    md = generate_metadata()
+
+    stored = await saver.aput(config, cp, md, {})
+    tup = await saver.aget_tuple(stored)
+    assert tup is not None
+    for node in vs:
+        assert node in tup.checkpoint["versions_seen"], f"versions_seen[{node}] missing"
+
+
+async def test_put_preserves_metadata(saver: BaseCheckpointSaver) -> None:
+    """Metadata source, step, parents, and custom keys round-trip."""
+    md = generate_metadata(source="loop", step=3, custom_key="custom_value")
+    config = generate_config()
+    cp = generate_checkpoint()
+
+    stored = await saver.aput(config, cp, md, {})
+    tup = await saver.aget_tuple(stored)
+    assert tup is not None
+    assert tup.metadata["source"] == "loop"
+    assert tup.metadata["step"] == 3
+    assert tup.metadata.get("custom_key") == "custom_value"
+
+
+async def test_put_root_namespace(saver: BaseCheckpointSaver) -> None:
+    """checkpoint_ns='' works."""
+    config = generate_config(checkpoint_ns="")
+    cp = generate_checkpoint()
+    md = generate_metadata()
+
+    stored = await saver.aput(config, cp, md, {})
+    tup = await saver.aget_tuple(stored)
+    assert tup is not None
+    assert tup.config["configurable"].get("checkpoint_ns", "") == ""
+
+
+async def test_put_child_namespace(saver: BaseCheckpointSaver) -> None:
+    """checkpoint_ns='child:abc' works."""
+    config = generate_config(checkpoint_ns="child:abc")
+    cp = generate_checkpoint()
+    md = generate_metadata()
+
+    stored = await saver.aput(config, cp, md, {})
+    tup = await saver.aget_tuple(stored)
+    assert tup is not None
+    assert tup.config["configurable"]["checkpoint_ns"] == "child:abc"
+
+
+async def test_put_default_namespace(saver: BaseCheckpointSaver) -> None:
+    """Config without checkpoint_ns defaults to ''."""
+    tid = str(uuid4())
+    config = {"configurable": {"thread_id": tid, "checkpoint_ns": ""}}
+    cp = generate_checkpoint()
+    md = generate_metadata()
+
+    stored = await saver.aput(config, cp, md, {})
+    tup = await saver.aget_tuple(stored)
+    assert tup is not None
+
+
+async def test_put_multiple_checkpoints_same_thread(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Sequential puts on same thread, all retrievable."""
+    tid = str(uuid4())
+    ids = []
+    parent_cfg = None
+    for i in range(3):
+        config = generate_config(tid)
+        if parent_cfg is not None:
+            config["configurable"]["checkpoint_id"] = parent_cfg["configurable"][
+                "checkpoint_id"
+            ]
+        cp = generate_checkpoint()
+        md = generate_metadata(step=i)
+        parent_cfg = await saver.aput(config, cp, md, {})
+        ids.append(cp["id"])
+
+    # All three should be retrievable
+    for cid in ids:
+        cfg = generate_config(tid, checkpoint_id=cid)
+        tup = await saver.aget_tuple(cfg)
+        assert tup is not None, f"checkpoint {cid} not found"
+        assert tup.checkpoint["id"] == cid
+
+
+async def test_put_multiple_threads_isolated(saver: BaseCheckpointSaver) -> None:
+    """Different thread_ids don't interfere."""
+    tid1, tid2 = str(uuid4()), str(uuid4())
+
+    config1 = generate_config(tid1)
+    cp1 = generate_checkpoint(channel_values={"x": "thread1"})
+    cp1["channel_versions"] = {"x": 1}
+    await saver.aput(config1, cp1, generate_metadata(), {"x": 1})
+
+    config2 = generate_config(tid2)
+    cp2 = generate_checkpoint(channel_values={"x": "thread2"})
+    cp2["channel_versions"] = {"x": 1}
+    await saver.aput(config2, cp2, generate_metadata(), {"x": 1})
+
+    tup1 = await saver.aget_tuple(generate_config(tid1))
+    tup2 = await saver.aget_tuple(generate_config(tid2))
+    assert tup1 is not None and tup2 is not None
+    assert tup1.checkpoint["channel_values"]["x"] == "thread1"
+    assert tup2.checkpoint["channel_values"]["x"] == "thread2"
+
+
+async def test_put_parent_config(saver: BaseCheckpointSaver) -> None:
+    """parent checkpoint_id tracked correctly."""
+    tid = str(uuid4())
+    config1 = generate_config(tid)
+    cp1 = generate_checkpoint()
+    stored1 = await saver.aput(config1, cp1, generate_metadata(step=0), {})
+
+    # Second checkpoint — its config carries the parent checkpoint_id
+    config2 = generate_config(tid)
+    config2["configurable"]["checkpoint_id"] = stored1["configurable"]["checkpoint_id"]
+    cp2 = generate_checkpoint()
+    stored2 = await saver.aput(config2, cp2, generate_metadata(step=1), {})
+
+    tup = await saver.aget_tuple(stored2)
+    assert tup is not None
+    assert tup.parent_config is not None
+    assert (
+        tup.parent_config["configurable"]["checkpoint_id"]
+        == stored1["configurable"]["checkpoint_id"]
+    )
+
+
+async def test_put_incremental_channel_update(saver: BaseCheckpointSaver) -> None:
+    """Only updated channels need new blobs; unchanged channels loaded from prior versions."""
+    tid = str(uuid4())
+
+    # Checkpoint 1: both channels are new
+    config1 = generate_config(tid)
+    cp1 = generate_checkpoint(
+        channel_values={"a": "v1", "b": "v2"},
+        channel_versions={"a": 1, "b": 1},
+    )
+    stored1 = await saver.aput(
+        config1, cp1, generate_metadata(step=0), {"a": 1, "b": 1}
+    )
+
+    # Checkpoint 2: only 'a' is updated
+    config2 = generate_config(tid)
+    config2["configurable"]["checkpoint_id"] = stored1["configurable"]["checkpoint_id"]
+    cp2 = generate_checkpoint(
+        channel_values={"a": "v1_updated", "b": "v2"},
+        channel_versions={"a": 2, "b": 1},
+    )
+    stored2 = await saver.aput(config2, cp2, generate_metadata(step=1), {"a": 2})
+
+    # cp2 should reconstruct full channel_values from blobs at mixed versions
+    tup2 = await saver.aget_tuple(stored2)
+    assert tup2 is not None
+    assert tup2.checkpoint["channel_values"].get("a") == "v1_updated", (
+        f"a: expected 'v1_updated', got {tup2.checkpoint['channel_values'].get('a')!r}"
+    )
+    assert tup2.checkpoint["channel_values"].get("b") == "v2", (
+        f"b: expected 'v2', got {tup2.checkpoint['channel_values'].get('b')!r}"
+    )
+
+    # cp1 should still return original values
+    tup1 = await saver.aget_tuple(stored1)
+    assert tup1 is not None
+    assert tup1.checkpoint["channel_values"].get("a") == "v1"
+    assert tup1.checkpoint["channel_values"].get("b") == "v2"
+
+
+async def test_put_new_channel_added(saver: BaseCheckpointSaver) -> None:
+    """A channel that appears for the first time in a later checkpoint."""
+    tid = str(uuid4())
+
+    config1 = generate_config(tid)
+    cp1 = generate_checkpoint(
+        channel_values={"a": "v1"},
+        channel_versions={"a": 1},
+    )
+    stored1 = await saver.aput(config1, cp1, generate_metadata(step=0), {"a": 1})
+
+    # Checkpoint 2: 'b' is brand new, 'a' is unchanged
+    config2 = generate_config(tid)
+    config2["configurable"]["checkpoint_id"] = stored1["configurable"]["checkpoint_id"]
+    cp2 = generate_checkpoint(
+        channel_values={"a": "v1", "b": "new_channel"},
+        channel_versions={"a": 1, "b": 1},
+    )
+    stored2 = await saver.aput(config2, cp2, generate_metadata(step=1), {"b": 1})
+
+    tup2 = await saver.aget_tuple(stored2)
+    assert tup2 is not None
+    assert tup2.checkpoint["channel_values"].get("a") == "v1", (
+        f"a: expected 'v1', got {tup2.checkpoint['channel_values'].get('a')!r}"
+    )
+    assert tup2.checkpoint["channel_values"].get("b") == "new_channel", (
+        f"b: expected 'new_channel', got {tup2.checkpoint['channel_values'].get('b')!r}"
+    )
+
+
+async def test_put_channel_removed(saver: BaseCheckpointSaver) -> None:
+    """Channel no longer in channel_versions should not appear in loaded values."""
+    tid = str(uuid4())
+
+    config1 = generate_config(tid)
+    cp1 = generate_checkpoint(
+        channel_values={"a": "v1", "b": "v2"},
+        channel_versions={"a": 1, "b": 1},
+    )
+    stored1 = await saver.aput(
+        config1, cp1, generate_metadata(step=0), {"a": 1, "b": 1}
+    )
+
+    # Checkpoint 2: 'b' dropped from channel_versions
+    config2 = generate_config(tid)
+    config2["configurable"]["checkpoint_id"] = stored1["configurable"]["checkpoint_id"]
+    cp2 = generate_checkpoint(
+        channel_values={"a": "v1_updated"},
+        channel_versions={"a": 2},
+    )
+    stored2 = await saver.aput(config2, cp2, generate_metadata(step=1), {"a": 2})
+
+    tup2 = await saver.aget_tuple(stored2)
+    assert tup2 is not None
+    assert tup2.checkpoint["channel_values"].get("a") == "v1_updated"
+    assert "b" not in tup2.checkpoint["channel_values"], (
+        f"'b' should not be present, got {tup2.checkpoint['channel_values']}"
+    )
+
+
+async def test_put_preserves_run_id(saver: BaseCheckpointSaver) -> None:
+    """run_id in metadata round-trips correctly."""
+    run_id = str(uuid4())
+    config = generate_config()
+    cp = generate_checkpoint()
+    md = generate_metadata(source="loop", step=0, run_id=run_id)
+
+    stored = await saver.aput(config, cp, md, {})
+    tup = await saver.aget_tuple(stored)
+    assert tup is not None
+    assert tup.metadata.get("run_id") == run_id, (
+        f"run_id: expected {run_id!r}, got {tup.metadata.get('run_id')!r}"
+    )
+
+
+async def test_put_preserves_versions_seen_values(saver: BaseCheckpointSaver) -> None:
+    """versions_seen values (not just keys) round-trip correctly."""
+    vs: dict[str, ChannelVersions] = {
+        "node1": {"ch_a": 1, "ch_b": 2},
+        "node2": {"ch_a": 3},
+    }
+    config = generate_config()
+    cp = generate_checkpoint(versions_seen=vs)
+    md = generate_metadata()
+
+    stored = await saver.aput(config, cp, md, {})
+    tup = await saver.aget_tuple(stored)
+    assert tup is not None
+    for node, expected_versions in vs.items():
+        assert node in tup.checkpoint["versions_seen"], f"versions_seen[{node}] missing"
+        actual_versions = tup.checkpoint["versions_seen"][node]
+        for ch, expected_v in expected_versions.items():
+            actual_v = actual_versions.get(ch)
+            assert actual_v is not None, f"versions_seen[{node}][{ch}] missing"
+            assert str(actual_v).split(".")[0] == str(expected_v).split(".")[0], (
+                f"versions_seen[{node}][{ch}]: expected {expected_v!r}, got {actual_v!r}"
+            )
+
+
+ALL_PUT_TESTS = [
+    test_put_returns_config,
+    test_put_roundtrip,
+    test_put_preserves_channel_values,
+    test_put_preserves_channel_versions,
+    test_put_preserves_versions_seen,
+    test_put_preserves_metadata,
+    test_put_root_namespace,
+    test_put_child_namespace,
+    test_put_default_namespace,
+    test_put_multiple_checkpoints_same_thread,
+    test_put_multiple_threads_isolated,
+    test_put_parent_config,
+    test_put_incremental_channel_update,
+    test_put_new_channel_added,
+    test_put_channel_removed,
+    test_put_preserves_run_id,
+    test_put_preserves_versions_seen_values,
+]
+
+
+async def run_put_tests(
+    saver: BaseCheckpointSaver,
+    on_test_result: Callable[[str, str, bool, str | None], None] | None = None,
+) -> tuple[int, int, list[str]]:
+    """Run all put tests. Returns (passed, failed, failure_names)."""
+    passed = 0
+    failed = 0
+    failures: list[str] = []
+    for test_fn in ALL_PUT_TESTS:
+        try:
+            await test_fn(saver)
+            passed += 1
+            if on_test_result:
+                on_test_result("put", test_fn.__name__, True, None)
+        except Exception as e:
+            failed += 1
+            msg = f"{test_fn.__name__}: {e}"
+            failures.append(msg)
+            if on_test_result:
+                on_test_result("put", test_fn.__name__, False, traceback.format_exc())
+    return passed, failed, failures

libs/checkpoint-conformance/langgraph/checkpoint/conformance/spec/test_put_writes.py

@@ -0,0 +1,302 @@
+"""PUT_WRITES capability tests — aput_writes + pending_writes retrieval."""
+
+from __future__ import annotations
+
+import traceback
+from collections.abc import Callable
+from uuid import uuid4
+
+from langgraph.checkpoint.base import BaseCheckpointSaver
+
+from langgraph.checkpoint.conformance.test_utils import (
+    generate_checkpoint,
+    generate_config,
+    generate_metadata,
+)
+
+
+async def test_put_writes_basic(saver: BaseCheckpointSaver) -> None:
+    """Write stored, visible in aget_tuple pending_writes."""
+    tid = str(uuid4())
+    config = generate_config(tid)
+    cp = generate_checkpoint()
+    stored = await saver.aput(config, cp, generate_metadata(), {})
+
+    task_id = str(uuid4())
+    await saver.aput_writes(stored, [("channel1", "value1")], task_id)
+
+    tup = await saver.aget_tuple(stored)
+    assert tup is not None
+    assert tup.pending_writes is not None
+    # Verify exact write tuple: (task_id, channel, value)
+    matching = [w for w in tup.pending_writes if w[0] == task_id and w[1] == "channel1"]
+    assert len(matching) == 1, f"Expected 1 write, got {len(matching)}"
+    assert matching[0][2] == "value1", f"Value mismatch: {matching[0][2]!r}"
+
+
+async def test_put_writes_multiple_writes_same_task(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Multiple (channel, value) pairs in a single call."""
+    tid = str(uuid4())
+    config = generate_config(tid)
+    cp = generate_checkpoint()
+    stored = await saver.aput(config, cp, generate_metadata(), {})
+
+    task_id = str(uuid4())
+    writes = [("ch1", "v1"), ("ch2", "v2"), ("ch3", "v3")]
+    await saver.aput_writes(stored, writes, task_id)
+
+    tup = await saver.aget_tuple(stored)
+    assert tup is not None
+    assert tup.pending_writes is not None
+    assert len(tup.pending_writes) == 3, (
+        f"Expected 3 writes, got {len(tup.pending_writes)}"
+    )
+    channels = {w[1] for w in tup.pending_writes}
+    assert channels == {"ch1", "ch2", "ch3"}, f"Expected exact channels, got {channels}"
+    # Verify values per channel
+    for expected_ch, expected_val in writes:
+        match = [
+            w for w in tup.pending_writes if w[0] == task_id and w[1] == expected_ch
+        ]
+        assert len(match) == 1, f"Expected 1 write for {expected_ch}, got {len(match)}"
+        assert match[0][2] == expected_val, (
+            f"Value mismatch for {expected_ch}: {match[0][2]!r}"
+        )
+
+
+async def test_put_writes_multiple_tasks(saver: BaseCheckpointSaver) -> None:
+    """Different task_ids produce separate writes."""
+    tid = str(uuid4())
+    config = generate_config(tid)
+    cp = generate_checkpoint()
+    stored = await saver.aput(config, cp, generate_metadata(), {})
+
+    t1, t2 = str(uuid4()), str(uuid4())
+    await saver.aput_writes(stored, [("ch", "from_t1")], t1)
+    await saver.aput_writes(stored, [("ch", "from_t2")], t2)
+
+    tup = await saver.aget_tuple(stored)
+    assert tup is not None
+    assert tup.pending_writes is not None
+    assert len(tup.pending_writes) == 2, (
+        f"Expected 2 writes, got {len(tup.pending_writes)}"
+    )
+    # Verify values per task
+    t1_writes = [w for w in tup.pending_writes if w[0] == t1 and w[1] == "ch"]
+    t2_writes = [w for w in tup.pending_writes if w[0] == t2 and w[1] == "ch"]
+    assert len(t1_writes) == 1, f"Expected 1 write from t1, got {len(t1_writes)}"
+    assert len(t2_writes) == 1, f"Expected 1 write from t2, got {len(t2_writes)}"
+    assert t1_writes[0][2] == "from_t1", f"t1 value: {t1_writes[0][2]!r}"
+    assert t2_writes[0][2] == "from_t2", f"t2 value: {t2_writes[0][2]!r}"
+
+
+async def test_put_writes_preserves_task_id(saver: BaseCheckpointSaver) -> None:
+    """task_id in pending_writes matches what was passed to aput_writes."""
+    tid = str(uuid4())
+    config = generate_config(tid)
+    cp = generate_checkpoint()
+    stored = await saver.aput(config, cp, generate_metadata(), {})
+
+    task_id = str(uuid4())
+    await saver.aput_writes(stored, [("ch", "val")], task_id)
+
+    tup = await saver.aget_tuple(stored)
+    assert tup is not None
+    assert tup.pending_writes is not None
+    assert any(w[0] == task_id for w in tup.pending_writes)
+
+
+async def test_put_writes_preserves_channel_and_value(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """Channel name + value round-trip."""
+    tid = str(uuid4())
+    config = generate_config(tid)
+    cp = generate_checkpoint()
+    stored = await saver.aput(config, cp, generate_metadata(), {})
+
+    task_id = str(uuid4())
+    await saver.aput_writes(stored, [("my_channel", {"data": 123})], task_id)
+
+    tup = await saver.aget_tuple(stored)
+    assert tup is not None
+    assert tup.pending_writes is not None
+    match = [w for w in tup.pending_writes if w[0] == task_id and w[1] == "my_channel"]
+    assert len(match) == 1, f"Expected 1 write, got {len(match)}"
+    assert match[0][2] == {"data": 123}, f"Value mismatch: {match[0][2]!r}"
+
+
+async def test_put_writes_task_path(saver: BaseCheckpointSaver) -> None:
+    """task_path parameter accepted without error."""
+    tid = str(uuid4())
+    config = generate_config(tid)
+    cp = generate_checkpoint()
+    stored = await saver.aput(config, cp, generate_metadata(), {})
+
+    task_id = str(uuid4())
+    # Should not raise
+    await saver.aput_writes(stored, [("ch", "v")], task_id, task_path="a:b:c")
+
+    tup = await saver.aget_tuple(stored)
+    assert tup is not None
+    assert tup.pending_writes is not None
+    assert len(tup.pending_writes) == 1
+
+
+async def test_put_writes_idempotent(saver: BaseCheckpointSaver) -> None:
+    """Duplicate (task_id, idx) doesn't duplicate writes."""
+    tid = str(uuid4())
+    config = generate_config(tid)
+    cp = generate_checkpoint()
+    stored = await saver.aput(config, cp, generate_metadata(), {})
+
+    task_id = str(uuid4())
+    await saver.aput_writes(stored, [("ch", "val")], task_id)
+    await saver.aput_writes(stored, [("ch", "val")], task_id)
+
+    tup = await saver.aget_tuple(stored)
+    assert tup is not None
+    assert tup.pending_writes is not None
+    assert len(tup.pending_writes) == 1, (
+        f"Expected exactly 1 write total, got {len(tup.pending_writes)}"
+    )
+    # Should not have duplicated
+    matching = [w for w in tup.pending_writes if w[0] == task_id and w[1] == "ch"]
+    assert len(matching) == 1
+
+
+async def test_put_writes_special_channels(saver: BaseCheckpointSaver) -> None:
+    """ERROR and INTERRUPT channels handled correctly."""
+    from langgraph.checkpoint.serde.types import ERROR, INTERRUPT
+
+    tid = str(uuid4())
+    config = generate_config(tid)
+    cp = generate_checkpoint()
+    stored = await saver.aput(config, cp, generate_metadata(), {})
+
+    task_id = str(uuid4())
+    await saver.aput_writes(
+        stored,
+        [(ERROR, "something went wrong"), (INTERRUPT, {"reason": "human_input"})],
+        task_id,
+    )
+
+    tup = await saver.aget_tuple(stored)
+    assert tup is not None
+    assert tup.pending_writes is not None
+    channels = {w[1] for w in tup.pending_writes}
+    assert ERROR in channels
+    assert INTERRUPT in channels
+    # Verify values
+    err_writes = [w for w in tup.pending_writes if w[0] == task_id and w[1] == ERROR]
+    assert len(err_writes) == 1, f"Expected 1 ERROR write, got {len(err_writes)}"
+    assert err_writes[0][2] == "something went wrong", (
+        f"ERROR value: {err_writes[0][2]!r}"
+    )
+    int_writes = [
+        w for w in tup.pending_writes if w[0] == task_id and w[1] == INTERRUPT
+    ]
+    assert len(int_writes) == 1, f"Expected 1 INTERRUPT write, got {len(int_writes)}"
+    assert int_writes[0][2] == {"reason": "human_input"}, (
+        f"INTERRUPT value: {int_writes[0][2]!r}"
+    )
+
+
+async def test_put_writes_across_namespaces(saver: BaseCheckpointSaver) -> None:
+    """Writes isolated by checkpoint_ns."""
+    tid = str(uuid4())
+
+    # Root namespace checkpoint + write
+    cfg_root = generate_config(tid, checkpoint_ns="")
+    cp_root = generate_checkpoint()
+    stored_root = await saver.aput(cfg_root, cp_root, generate_metadata(), {})
+    root_task = str(uuid4())
+    await saver.aput_writes(stored_root, [("ch", "root_val")], root_task)
+
+    # Child namespace checkpoint + write
+    cfg_child = generate_config(tid, checkpoint_ns="child:1")
+    cp_child = generate_checkpoint()
+    stored_child = await saver.aput(cfg_child, cp_child, generate_metadata(), {})
+    child_task = str(uuid4())
+    await saver.aput_writes(stored_child, [("ch", "child_val")], child_task)
+
+    # Verify isolation — root should have exactly 1 write with root_val
+    tup_root = await saver.aget_tuple(stored_root)
+    assert tup_root is not None
+    assert tup_root.pending_writes is not None
+    root_ch = [w for w in tup_root.pending_writes if w[1] == "ch"]
+    assert len(root_ch) == 1, f"Expected 1 root write, got {len(root_ch)}"
+    assert root_ch[0][2] == "root_val", f"Root value: {root_ch[0][2]!r}"
+
+    # Child should have exactly 1 write with child_val
+    tup_child = await saver.aget_tuple(stored_child)
+    assert tup_child is not None
+    assert tup_child.pending_writes is not None
+    child_ch = [w for w in tup_child.pending_writes if w[1] == "ch"]
+    assert len(child_ch) == 1, f"Expected 1 child write, got {len(child_ch)}"
+    assert child_ch[0][2] == "child_val", f"Child value: {child_ch[0][2]!r}"
+
+
+async def test_put_writes_cleared_on_next_checkpoint(
+    saver: BaseCheckpointSaver,
+) -> None:
+    """New checkpoint starts with fresh pending_writes."""
+    tid = str(uuid4())
+    config = generate_config(tid)
+    cp1 = generate_checkpoint()
+    stored1 = await saver.aput(config, cp1, generate_metadata(step=0), {})
+
+    await saver.aput_writes(stored1, [("ch", "old_write")], str(uuid4()))
+
+    # New checkpoint
+    config2 = generate_config(tid)
+    config2["configurable"]["checkpoint_id"] = stored1["configurable"]["checkpoint_id"]
+    cp2 = generate_checkpoint()
+    stored2 = await saver.aput(config2, cp2, generate_metadata(step=1), {})
+
+    tup = await saver.aget_tuple(stored2)
+    assert tup is not None
+    # New checkpoint should have no pending writes
+    writes = tup.pending_writes or []
+    assert len(writes) == 0
+
+
+ALL_PUT_WRITES_TESTS = [
+    test_put_writes_basic,
+    test_put_writes_multiple_writes_same_task,
+    test_put_writes_multiple_tasks,
+    test_put_writes_preserves_task_id,
+    test_put_writes_preserves_channel_and_value,
+    test_put_writes_task_path,
+    test_put_writes_idempotent,
+    test_put_writes_special_channels,
+    test_put_writes_across_namespaces,
+    test_put_writes_cleared_on_next_checkpoint,
+]
+
+
+async def run_put_writes_tests(
+    saver: BaseCheckpointSaver,
+    on_test_result: Callable[[str, str, bool, str | None], None] | None = None,
+) -> tuple[int, int, list[str]]:
+    """Run all put_writes tests. Returns (passed, failed, failure_names)."""
+    passed = 0
+    failed = 0
+    failures: list[str] = []
+    for test_fn in ALL_PUT_WRITES_TESTS:
+        try:
+            await test_fn(saver)
+            passed += 1
+            if on_test_result:
+                on_test_result("put_writes", test_fn.__name__, True, None)
+        except Exception as e:
+            failed += 1
+            msg = f"{test_fn.__name__}: {e}"
+            failures.append(msg)
+            if on_test_result:
+                on_test_result(
+                    "put_writes", test_fn.__name__, False, traceback.format_exc()
+                )
+    return passed, failed, failures

libs/checkpoint-conformance/langgraph/checkpoint/conformance/test_utils.py

@@ -0,0 +1,212 @@
+"""Test utilities: checkpoint generators, assertion helpers, bulk operations."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+from uuid import uuid4
+
+from langchain_core.runnables import RunnableConfig
+from langgraph.checkpoint.base import (
+    ChannelVersions,
+    Checkpoint,
+    CheckpointMetadata,
+    CheckpointTuple,
+)
+from langgraph.checkpoint.base.id import uuid6
+
+
+def generate_checkpoint(
+    *,
+    checkpoint_id: str | None = None,
+    channel_values: dict[str, Any] | None = None,
+    channel_versions: ChannelVersions | None = None,
+    versions_seen: dict[str, ChannelVersions] | None = None,
+) -> Checkpoint:
+    """Create a well-formed Checkpoint with sensible defaults."""
+    return Checkpoint(
+        v=1,
+        id=checkpoint_id or str(uuid6(clock_seq=-1)),
+        ts=datetime.now(timezone.utc).isoformat(),
+        channel_values=channel_values if channel_values is not None else {},
+        channel_versions=channel_versions if channel_versions is not None else {},
+        versions_seen=versions_seen if versions_seen is not None else {},
+        pending_sends=[],  # ty: ignore[invalid-key]
+        updated_channels=None,
+    )
+
+
+def generate_config(
+    thread_id: str | None = None,
+    *,
+    checkpoint_ns: str = "",
+    checkpoint_id: str | None = None,
+) -> RunnableConfig:
+    """Create a RunnableConfig targeting a specific thread / namespace / checkpoint."""
+    configurable: dict[str, Any] = {
+        "thread_id": thread_id or str(uuid4()),
+        "checkpoint_ns": checkpoint_ns,
+    }
+    if checkpoint_id is not None:
+        configurable["checkpoint_id"] = checkpoint_id
+    return {"configurable": configurable}
+
+
+def generate_metadata(
+    source: str = "loop",
+    step: int = 0,
+    **extra: Any,
+) -> CheckpointMetadata:
+    """Create CheckpointMetadata with defaults."""
+    md: dict[str, Any] = {"source": source, "step": step, "parents": {}}
+    md.update(extra)
+    return md
+
+
+async def put_test_checkpoint(
+    saver: Any,
+    *,
+    thread_id: str | None = None,
+    checkpoint_ns: str = "",
+    parent_config: RunnableConfig | None = None,
+    channel_values: dict[str, Any] | None = None,
+    channel_versions: ChannelVersions | None = None,
+    metadata: CheckpointMetadata | None = None,
+    new_versions: ChannelVersions | None = None,
+) -> RunnableConfig:
+    """Put a single test checkpoint and return the stored config.
+
+    Handles wiring up parent_config, channel_values -> new_versions, etc.
+    """
+    tid = thread_id or str(uuid4())
+    cp = generate_checkpoint(
+        channel_values=channel_values,
+        channel_versions=channel_versions,
+    )
+
+    # When channel_values are provided, ensure channel_versions + new_versions
+    # are consistent so the checkpointer stores the blobs correctly.
+    vals = channel_values or {}
+    cv = channel_versions
+    if cv is None and vals:
+        cv = {k: 1 for k in vals}
+        cp["channel_versions"] = cv
+    nv = new_versions
+    if nv is None:
+        nv = cv or {}
+
+    md = metadata or generate_metadata()
+
+    config = generate_config(tid, checkpoint_ns=checkpoint_ns)
+    if parent_config is not None:
+        config["configurable"]["checkpoint_id"] = parent_config["configurable"][
+            "checkpoint_id"
+        ]
+
+    return await saver.aput(config, cp, md, nv)
+
+
+async def put_test_checkpoints(
+    saver: Any,
+    *,
+    n_threads: int = 1,
+    n_checkpoints: int = 1,
+    namespaces: list[str] | None = None,
+    channel_values: dict[str, Any] | None = None,
+) -> list[RunnableConfig]:
+    """Convenience: put multiple checkpoints across threads/namespaces.
+
+    Returns the stored configs in insertion order.
+    """
+    nss = namespaces or [""]
+    stored: list[RunnableConfig] = []
+    for t in range(n_threads):
+        tid = f"thread-{t}"
+        for ns in nss:
+            parent: RunnableConfig | None = None
+            for _c in range(n_checkpoints):
+                cfg = await put_test_checkpoint(
+                    saver,
+                    thread_id=tid,
+                    checkpoint_ns=ns,
+                    parent_config=parent,
+                    channel_values=channel_values,
+                )
+                parent = cfg
+                stored.append(cfg)
+    return stored
+
+
+def assert_checkpoint_equal(
+    actual: Checkpoint,
+    expected: Checkpoint,
+    *,
+    check_channel_values: bool = True,
+) -> None:
+    """Assert two checkpoints are semantically equal."""
+    assert actual["v"] == expected["v"], f"v mismatch: {actual['v']} != {expected['v']}"
+    assert actual["id"] == expected["id"], (
+        f"id mismatch: {actual['id']} != {expected['id']}"
+    )
+    assert actual["channel_versions"] == expected["channel_versions"], (
+        "channel_versions mismatch"
+    )
+    assert actual["versions_seen"] == expected["versions_seen"], (
+        "versions_seen mismatch"
+    )
+    if check_channel_values:
+        assert actual["channel_values"] == expected["channel_values"], (
+            "channel_values mismatch"
+        )
+
+
+def assert_tuple_equal(
+    actual: CheckpointTuple,
+    expected: CheckpointTuple,
+    *,
+    check_writes: bool = True,
+    check_channel_values: bool = True,
+) -> None:
+    """Assert two CheckpointTuples are semantically equal."""
+    # Config
+    a_conf = actual.config["configurable"]
+    e_conf = expected.config["configurable"]
+    assert a_conf["thread_id"] == e_conf["thread_id"], (
+        f"thread_id mismatch: {a_conf['thread_id']} != {e_conf['thread_id']}"
+    )
+    assert a_conf.get("checkpoint_ns", "") == e_conf.get("checkpoint_ns", ""), (
+        "checkpoint_ns mismatch"
+    )
+    assert a_conf["checkpoint_id"] == e_conf["checkpoint_id"], "checkpoint_id mismatch"
+
+    # Checkpoint
+    assert_checkpoint_equal(
+        actual.checkpoint,
+        expected.checkpoint,
+        check_channel_values=check_channel_values,
+    )
+
+    # Metadata
+    for k, v in expected.metadata.items():
+        assert actual.metadata.get(k) == v, (
+            f"metadata[{k}] mismatch: {actual.metadata.get(k)} != {v}"
+        )
+
+    # Parent config
+    if expected.parent_config is not None:
+        assert actual.parent_config is not None, "expected parent_config, got None"
+        assert (
+            actual.parent_config["configurable"]["checkpoint_id"]
+            == expected.parent_config["configurable"]["checkpoint_id"]
+        ), "parent checkpoint_id mismatch"
+    else:
+        assert actual.parent_config is None, (
+            f"expected no parent_config, got {actual.parent_config}"
+        )
+
+    # Pending writes
+    if check_writes and expected.pending_writes is not None:
+        assert actual.pending_writes is not None
+        assert len(actual.pending_writes) == len(expected.pending_writes), (
+            f"pending_writes length mismatch: {len(actual.pending_writes)} != {len(expected.pending_writes)}"
+        )

libs/checkpoint-conformance/langgraph/checkpoint/conformance/validate.py

@@ -0,0 +1,124 @@
+"""Core conformance runner — detects capabilities, runs test suites, builds report."""
+
+from __future__ import annotations
+
+from langgraph.checkpoint.conformance.capabilities import (
+    Capability,
+    DetectedCapabilities,
+)
+from langgraph.checkpoint.conformance.initializer import RegisteredCheckpointer
+from langgraph.checkpoint.conformance.report import (
+    CapabilityReport,
+    CapabilityResult,
+    ProgressCallbacks,
+)
+from langgraph.checkpoint.conformance.spec.test_copy_thread import run_copy_thread_tests
+from langgraph.checkpoint.conformance.spec.test_delete_for_runs import (
+    run_delete_for_runs_tests,
+)
+from langgraph.checkpoint.conformance.spec.test_delete_thread import (
+    run_delete_thread_tests,
+)
+from langgraph.checkpoint.conformance.spec.test_get_tuple import run_get_tuple_tests
+from langgraph.checkpoint.conformance.spec.test_list import run_list_tests
+from langgraph.checkpoint.conformance.spec.test_prune import run_prune_tests
+from langgraph.checkpoint.conformance.spec.test_put import run_put_tests
+from langgraph.checkpoint.conformance.spec.test_put_writes import run_put_writes_tests
+
+# Maps capability to its runner function.
+_RUNNERS = {
+    Capability.PUT: run_put_tests,
+    Capability.PUT_WRITES: run_put_writes_tests,
+    Capability.GET_TUPLE: run_get_tuple_tests,
+    Capability.LIST: run_list_tests,
+    Capability.DELETE_THREAD: run_delete_thread_tests,
+    Capability.DELETE_FOR_RUNS: run_delete_for_runs_tests,
+    Capability.COPY_THREAD: run_copy_thread_tests,
+    Capability.PRUNE: run_prune_tests,
+}
+
+
+async def validate(
+    registered: RegisteredCheckpointer,
+    *,
+    capabilities: set[str] | None = None,
+    progress: ProgressCallbacks | None = None,
+) -> CapabilityReport:
+    """Run the validation suite against a registered checkpointer.
+
+    Args:
+        registered: A RegisteredCheckpointer (from @checkpointer_test decorator).
+        capabilities: If given, only run tests for these capability names.
+            Otherwise, auto-detect and run all applicable tests.
+        progress: Optional progress callbacks for incremental output.
+            Use ``ProgressCallbacks.default()`` for dot-style,
+            ``ProgressCallbacks.verbose()`` for per-test output, or
+            ``None`` / ``ProgressCallbacks.quiet()`` for silent mode.
+
+    Returns:
+        A CapabilityReport with per-capability results.
+    """
+    report = CapabilityReport(checkpointer_name=registered.name)
+
+    # Determine which capabilities to test.
+    caps_to_test: set[Capability]
+    if capabilities is not None:
+        caps_to_test = {Capability(c) for c in capabilities}
+    else:
+        caps_to_test = set(Capability)
+
+    async with registered.enter_lifespan():
+        for cap in Capability:
+            if cap in caps_to_test and cap.value not in registered.skip_capabilities:
+                # Create a fresh checkpointer for each capability suite.
+                async with registered.create() as saver:
+                    detected = DetectedCapabilities.from_instance(saver)
+                    is_detected = cap in detected.detected
+
+                    if not is_detected:
+                        if progress and progress.on_capability_start:
+                            progress.on_capability_start(cap.value, False)
+                        report.results[cap.value] = CapabilityResult(
+                            detected=False,
+                            passed=None,
+                            tests_skipped=1,
+                        )
+                        continue
+
+                    runner = _RUNNERS.get(cap)
+                    if runner is None:
+                        report.results[cap.value] = CapabilityResult(
+                            detected=True,
+                            passed=None,
+                            tests_skipped=1,
+                        )
+                        continue
+
+                    if progress and progress.on_capability_start:
+                        progress.on_capability_start(cap.value, True)
+
+                    passed, failed, failures = await runner(
+                        saver,
+                        on_test_result=progress.on_test_result if progress else None,
+                    )
+
+                    if progress and progress.on_capability_end:
+                        progress.on_capability_end(cap.value)
+
+                    report.results[cap.value] = CapabilityResult(
+                        detected=True,
+                        passed=failed == 0,
+                        tests_passed=passed,
+                        tests_failed=failed,
+                        failures=failures,
+                    )
+            else:
+                if progress and progress.on_capability_start:
+                    progress.on_capability_start(cap.value, False)
+                report.results[cap.value] = CapabilityResult(
+                    detected=False,
+                    passed=None,
+                    tests_skipped=1,
+                )
+
+    return report

libs/checkpoint-conformance/pyproject.toml

@@ -0,0 +1,59 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "langgraph-checkpoint-conformance"
+version = "0.0.1"
+description = "Conformance test suite for LangGraph checkpointer implementations."
+authors = [{name = "William FH", email = "13333726+hinthornw@users.noreply.github.com"}]
+requires-python = ">=3.10"
+readme = "README.md"
+license = "MIT"
+dependencies = [
+    "langgraph-checkpoint>=2.0.0",
+]
+
+[project.urls]
+Source = "https://github.com/langchain-ai/langgraph/tree/main/libs/checkpoint-conformance"
+
+[dependency-groups]
+test = [
+  "pytest",
+  "pytest-asyncio",
+]
+lint = [
+  "ruff",
+  "ty",
+]
+dev = [
+  {include-group = "test"},
+  {include-group = "lint"},
+]
+
+[tool.hatch.build.targets.wheel]
+include = ["langgraph"]
+
+[tool.pytest.ini_options]
+addopts = "--strict-markers --strict-config --durations=5 -vv"
+testpaths = ["tests"]
+asyncio_mode = "auto"
+
+[tool.ty.rules]
+# The extended methods (acopy_thread, adelete_for_runs, aprune) are checked
+# at runtime via capability detection and may not exist on the installed
+# base class. Dict literal inference is also overly strict for RunnableConfig.
+unresolved-attribute = "ignore"
+invalid-argument-type = "ignore"
+invalid-return-type = "ignore"
+
+[tool.ruff]
+lint.select = [
+  "E",  # pycodestyle
+  "F",  # Pyflakes
+  "UP", # pyupgrade
+  "B",  # flake8-bugbear
+  "I",  # isort
+]
+lint.ignore = ["E501", "B008"]
+target-version = "py310"

libs/checkpoint-conformance/tests/test_validate_memory.py

@@ -0,0 +1,21 @@
+"""Self-tests: run the conformance suite against InMemorySaver."""
+
+from __future__ import annotations
+
+import pytest
+from langgraph.checkpoint.memory import InMemorySaver
+
+from langgraph.checkpoint.conformance import checkpointer_test, validate
+
+
+@checkpointer_test(name="InMemorySaver")
+async def memory_checkpointer():
+    yield InMemorySaver()
+
+
+@pytest.mark.asyncio
+async def test_validate_memory_base():
+    """InMemorySaver passes all base capability tests."""
+    report = await validate(memory_checkpointer)
+    report.print_report()
+    assert report.passed_all_base(), f"Base tests failed: {report.to_dict()}"

libs/checkpoint-postgres/uv.lock

@@ -240,7 +240,7 @@ wheels = [
 
 [[package]]
 name = "langchain-core"
-version = "1.2.7"
+version = "1.2.11"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jsonpatch" },
@@ -252,9 +252,9 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "uuid-utils" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a2/0e/664d8d81b3493e09cbab72448d2f9d693d1fa5aa2bcc488602203a9b6da0/langchain_core-1.2.7.tar.gz", hash = "sha256:e1460639f96c352b4a41c375f25aeb8d16ffc1769499fb1c20503aad59305ced", size = 837039, upload-time = "2026-01-09T17:44:25.505Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/12/17/1943cedfc118e04b8128e4c3e1dbf0fa0ea58eefddbb6198cfd699d19f01/langchain_core-1.2.11.tar.gz", hash = "sha256:f164bb36602dd74a3a50c1334fca75309ad5ed95767acdfdbb9fa95ce28a1e01", size = 831211, upload-time = "2026-02-10T20:35:28.35Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6e/6f/34a9fba14d191a67f7e2ee3dbce3e9b86d2fa7310e2c7f2c713583481bd2/langchain_core-1.2.7-py3-none-any.whl", hash = "sha256:452f4fef7a3d883357b22600788d37e3d8854ef29da345b7ac7099f33c31828b", size = 490232, upload-time = "2026-01-09T17:44:24.236Z" },
+    { url = "https://files.pythonhosted.org/packages/10/30/1f80e3fc674353cad975ed5294353d42512535d2094ef032c06454c2c873/langchain_core-1.2.11-py3-none-any.whl", hash = "sha256:ae11ceb8dda60d0b9d09e763116e592f1683327c17be5b715f350fd29aee65d3", size = 500062, upload-time = "2026-02-10T20:35:26.698Z" },
 ]
 
 [[package]]
@@ -528,83 +528,83 @@ wheels = [
 
 [[package]]
 name = "orjson"
-version = "3.11.5"
+version = "3.11.7"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/04/b8/333fdb27840f3bf04022d21b654a35f58e15407183aeb16f3b41aa053446/orjson-3.11.5.tar.gz", hash = "sha256:82393ab47b4fe44ffd0a7659fa9cfaacc717eb617c93cde83795f14af5c2e9d5", size = 5972347, upload-time = "2025-12-06T15:55:39.458Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/45/b268004f745ede84e5798b48ee12b05129d19235d0e15267aa57dcdb400b/orjson-3.11.7.tar.gz", hash = "sha256:9b1a67243945819ce55d24a30b59d6a168e86220452d2c96f4d1f093e71c0c49", size = 6144992, upload-time = "2026-02-02T15:38:49.29Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/79/19/b22cf9dad4db20c8737041046054cbd4f38bb5a2d0e4bb60487832ce3d76/orjson-3.11.5-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:df9eadb2a6386d5ea2bfd81309c505e125cfc9ba2b1b99a97e60985b0b3665d1", size = 245719, upload-time = "2025-12-06T15:53:43.877Z" },
-    { url = "https://files.pythonhosted.org/packages/03/2e/b136dd6bf30ef5143fbe76a4c142828b55ccc618be490201e9073ad954a1/orjson-3.11.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ccc70da619744467d8f1f49a8cadae5ec7bbe054e5232d95f92ed8737f8c5870", size = 132467, upload-time = "2025-12-06T15:53:45.379Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/fc/ae99bfc1e1887d20a0268f0e2686eb5b13d0ea7bbe01de2b566febcd2130/orjson-3.11.5-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:073aab025294c2f6fc0807201c76fdaed86f8fc4be52c440fb78fbb759a1ac09", size = 130702, upload-time = "2025-12-06T15:53:46.659Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/43/ef7912144097765997170aca59249725c3ab8ef6079f93f9d708dd058df5/orjson-3.11.5-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:835f26fa24ba0bb8c53ae2a9328d1706135b74ec653ed933869b74b6909e63fd", size = 135907, upload-time = "2025-12-06T15:53:48.487Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/da/24d50e2d7f4092ddd4d784e37a3fa41f22ce8ed97abc9edd222901a96e74/orjson-3.11.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:667c132f1f3651c14522a119e4dd631fad98761fa960c55e8e7430bb2a1ba4ac", size = 139935, upload-time = "2025-12-06T15:53:49.88Z" },
-    { url = "https://files.pythonhosted.org/packages/02/4a/b4cb6fcbfff5b95a3a019a8648255a0fac9b221fbf6b6e72be8df2361feb/orjson-3.11.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:42e8961196af655bb5e63ce6c60d25e8798cd4dfbc04f4203457fa3869322c2e", size = 137541, upload-time = "2025-12-06T15:53:51.226Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/99/a11bd129f18c2377c27b2846a9d9be04acec981f770d711ba0aaea563984/orjson-3.11.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75412ca06e20904c19170f8a24486c4e6c7887dea591ba18a1ab572f1300ee9f", size = 139031, upload-time = "2025-12-06T15:53:52.309Z" },
-    { url = "https://files.pythonhosted.org/packages/64/29/d7b77d7911574733a036bb3e8ad7053ceb2b7d6ea42208b9dbc55b23b9ed/orjson-3.11.5-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:6af8680328c69e15324b5af3ae38abbfcf9cbec37b5346ebfd52339c3d7e8a18", size = 141622, upload-time = "2025-12-06T15:53:53.606Z" },
-    { url = "https://files.pythonhosted.org/packages/93/41/332db96c1de76b2feda4f453e91c27202cd092835936ce2b70828212f726/orjson-3.11.5-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:a86fe4ff4ea523eac8f4b57fdac319faf037d3c1be12405e6a7e86b3fbc4756a", size = 413800, upload-time = "2025-12-06T15:53:54.866Z" },
-    { url = "https://files.pythonhosted.org/packages/76/e1/5a0d148dd1f89ad2f9651df67835b209ab7fcb1118658cf353425d7563e9/orjson-3.11.5-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e607b49b1a106ee2086633167033afbd63f76f2999e9236f638b06b112b24ea7", size = 151198, upload-time = "2025-12-06T15:53:56.383Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/96/8db67430d317a01ae5cf7971914f6775affdcfe99f5bff9ef3da32492ecc/orjson-3.11.5-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7339f41c244d0eea251637727f016b3d20050636695bc78345cce9029b189401", size = 141984, upload-time = "2025-12-06T15:53:57.746Z" },
-    { url = "https://files.pythonhosted.org/packages/71/49/40d21e1aa1ac569e521069228bb29c9b5a350344ccf922a0227d93c2ed44/orjson-3.11.5-cp310-cp310-win32.whl", hash = "sha256:8be318da8413cdbbce77b8c5fac8d13f6eb0f0db41b30bb598631412619572e8", size = 135272, upload-time = "2025-12-06T15:53:59.769Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/7e/d0e31e78be0c100e08be64f48d2850b23bcb4d4c70d114f4e43b39f6895a/orjson-3.11.5-cp310-cp310-win_amd64.whl", hash = "sha256:b9f86d69ae822cabc2a0f6c099b43e8733dda788405cba2665595b7e8dd8d167", size = 133360, upload-time = "2025-12-06T15:54:01.25Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/68/6b3659daec3a81aed5ab47700adb1a577c76a5452d35b91c88efee89987f/orjson-3.11.5-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:9c8494625ad60a923af6b2b0bd74107146efe9b55099e20d7740d995f338fcd8", size = 245318, upload-time = "2025-12-06T15:54:02.355Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/00/92db122261425f61803ccf0830699ea5567439d966cbc35856fe711bfe6b/orjson-3.11.5-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:7bb2ce0b82bc9fd1168a513ddae7a857994b780b2945a8c51db4ab1c4b751ebc", size = 129491, upload-time = "2025-12-06T15:54:03.877Z" },
-    { url = "https://files.pythonhosted.org/packages/94/4f/ffdcb18356518809d944e1e1f77589845c278a1ebbb5a8297dfefcc4b4cb/orjson-3.11.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:67394d3becd50b954c4ecd24ac90b5051ee7c903d167459f93e77fc6f5b4c968", size = 132167, upload-time = "2025-12-06T15:54:04.944Z" },
-    { url = "https://files.pythonhosted.org/packages/97/c6/0a8caff96f4503f4f7dd44e40e90f4d14acf80d3b7a97cb88747bb712d3e/orjson-3.11.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:298d2451f375e5f17b897794bcc3e7b821c0f32b4788b9bcae47ada24d7f3cf7", size = 130516, upload-time = "2025-12-06T15:54:06.274Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/63/43d4dc9bd9954bff7052f700fdb501067f6fb134a003ddcea2a0bb3854ed/orjson-3.11.5-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aa5e4244063db8e1d87e0f54c3f7522f14b2dc937e65d5241ef0076a096409fd", size = 135695, upload-time = "2025-12-06T15:54:07.702Z" },
-    { url = "https://files.pythonhosted.org/packages/87/6f/27e2e76d110919cb7fcb72b26166ee676480a701bcf8fc53ac5d0edce32f/orjson-3.11.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1db2088b490761976c1b2e956d5d4e6409f3732e9d79cfa69f876c5248d1baf9", size = 139664, upload-time = "2025-12-06T15:54:08.828Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/f8/5966153a5f1be49b5fbb8ca619a529fde7bc71aa0a376f2bb83fed248bcd/orjson-3.11.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c2ed66358f32c24e10ceea518e16eb3549e34f33a9d51f99ce23b0251776a1ef", size = 137289, upload-time = "2025-12-06T15:54:09.898Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/34/8acb12ff0299385c8bbcbb19fbe40030f23f15a6de57a9c587ebf71483fb/orjson-3.11.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c2021afda46c1ed64d74b555065dbd4c2558d510d8cec5ea6a53001b3e5e82a9", size = 138784, upload-time = "2025-12-06T15:54:11.022Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/27/910421ea6e34a527f73d8f4ee7bdffa48357ff79c7b8d6eb6f7b82dd1176/orjson-3.11.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b42ffbed9128e547a1647a3e50bc88ab28ae9daa61713962e0d3dd35e820c125", size = 141322, upload-time = "2025-12-06T15:54:12.427Z" },
-    { url = "https://files.pythonhosted.org/packages/87/a3/4b703edd1a05555d4bb1753d6ce44e1a05b7a6d7c164d5b332c795c63d70/orjson-3.11.5-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:8d5f16195bb671a5dd3d1dbea758918bada8f6cc27de72bd64adfbd748770814", size = 413612, upload-time = "2025-12-06T15:54:13.858Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/36/034177f11d7eeea16d3d2c42a1883b0373978e08bc9dad387f5074c786d8/orjson-3.11.5-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:c0e5d9f7a0227df2927d343a6e3859bebf9208b427c79bd31949abcc2fa32fa5", size = 150993, upload-time = "2025-12-06T15:54:15.189Z" },
-    { url = "https://files.pythonhosted.org/packages/44/2f/ea8b24ee046a50a7d141c0227c4496b1180b215e728e3b640684f0ea448d/orjson-3.11.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:23d04c4543e78f724c4dfe656b3791b5f98e4c9253e13b2636f1af5d90e4a880", size = 141774, upload-time = "2025-12-06T15:54:16.451Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/12/cc440554bf8200eb23348a5744a575a342497b65261cd65ef3b28332510a/orjson-3.11.5-cp311-cp311-win32.whl", hash = "sha256:c404603df4865f8e0afe981aa3c4b62b406e6d06049564d58934860b62b7f91d", size = 135109, upload-time = "2025-12-06T15:54:17.73Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/83/e0c5aa06ba73a6760134b169f11fb970caa1525fa4461f94d76e692299d9/orjson-3.11.5-cp311-cp311-win_amd64.whl", hash = "sha256:9645ef655735a74da4990c24ffbd6894828fbfa117bc97c1edd98c282ecb52e1", size = 133193, upload-time = "2025-12-06T15:54:19.426Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/35/5b77eaebc60d735e832c5b1a20b155667645d123f09d471db0a78280fb49/orjson-3.11.5-cp311-cp311-win_arm64.whl", hash = "sha256:1cbf2735722623fcdee8e712cbaaab9e372bbcb0c7924ad711b261c2eccf4a5c", size = 126830, upload-time = "2025-12-06T15:54:20.836Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/a4/8052a029029b096a78955eadd68ab594ce2197e24ec50e6b6d2ab3f4e33b/orjson-3.11.5-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:334e5b4bff9ad101237c2d799d9fd45737752929753bf4faf4b207335a416b7d", size = 245347, upload-time = "2025-12-06T15:54:22.061Z" },
-    { url = "https://files.pythonhosted.org/packages/64/67/574a7732bd9d9d79ac620c8790b4cfe0717a3d5a6eb2b539e6e8995e24a0/orjson-3.11.5-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:ff770589960a86eae279f5d8aa536196ebda8273a2a07db2a54e82b93bc86626", size = 129435, upload-time = "2025-12-06T15:54:23.615Z" },
-    { url = "https://files.pythonhosted.org/packages/52/8d/544e77d7a29d90cf4d9eecd0ae801c688e7f3d1adfa2ebae5e1e94d38ab9/orjson-3.11.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ed24250e55efbcb0b35bed7caaec8cedf858ab2f9f2201f17b8938c618c8ca6f", size = 132074, upload-time = "2025-12-06T15:54:24.694Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/57/b9f5b5b6fbff9c26f77e785baf56ae8460ef74acdb3eae4931c25b8f5ba9/orjson-3.11.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a66d7769e98a08a12a139049aac2f0ca3adae989817f8c43337455fbc7669b85", size = 130520, upload-time = "2025-12-06T15:54:26.185Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/6d/d34970bf9eb33f9ec7c979a262cad86076814859e54eb9a059a52f6dc13d/orjson-3.11.5-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:86cfc555bfd5794d24c6a1903e558b50644e5e68e6471d66502ce5cb5fdef3f9", size = 136209, upload-time = "2025-12-06T15:54:27.264Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/39/bc373b63cc0e117a105ea12e57280f83ae52fdee426890d57412432d63b3/orjson-3.11.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a230065027bc2a025e944f9d4714976a81e7ecfa940923283bca7bbc1f10f626", size = 139837, upload-time = "2025-12-06T15:54:28.75Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/aa/7c4818c8d7d324da220f4f1af55c343956003aa4d1ce1857bdc1d396ba69/orjson-3.11.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b29d36b60e606df01959c4b982729c8845c69d1963f88686608be9ced96dbfaa", size = 137307, upload-time = "2025-12-06T15:54:29.856Z" },
-    { url = "https://files.pythonhosted.org/packages/46/bf/0993b5a056759ba65145effe3a79dd5a939d4a070eaa5da2ee3180fbb13f/orjson-3.11.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c74099c6b230d4261fdc3169d50efc09abf38ace1a42ea2f9994b1d79153d477", size = 139020, upload-time = "2025-12-06T15:54:31.024Z" },
-    { url = "https://files.pythonhosted.org/packages/65/e8/83a6c95db3039e504eda60fc388f9faedbb4f6472f5aba7084e06552d9aa/orjson-3.11.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e697d06ad57dd0c7a737771d470eedc18e68dfdefcdd3b7de7f33dfda5b6212e", size = 141099, upload-time = "2025-12-06T15:54:32.196Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/b4/24fdc024abfce31c2f6812973b0a693688037ece5dc64b7a60c1ce69e2f2/orjson-3.11.5-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:e08ca8a6c851e95aaecc32bc44a5aa75d0ad26af8cdac7c77e4ed93acf3d5b69", size = 413540, upload-time = "2025-12-06T15:54:33.361Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/37/01c0ec95d55ed0c11e4cae3e10427e479bba40c77312b63e1f9665e0737d/orjson-3.11.5-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e8b5f96c05fce7d0218df3fdfeb962d6b8cfff7e3e20264306b46dd8b217c0f3", size = 151530, upload-time = "2025-12-06T15:54:34.6Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/d4/f9ebc57182705bb4bbe63f5bbe14af43722a2533135e1d2fb7affa0c355d/orjson-3.11.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ddbfdb5099b3e6ba6d6ea818f61997bb66de14b411357d24c4612cf1ebad08ca", size = 141863, upload-time = "2025-12-06T15:54:35.801Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/04/02102b8d19fdcb009d72d622bb5781e8f3fae1646bf3e18c53d1bc8115b5/orjson-3.11.5-cp312-cp312-win32.whl", hash = "sha256:9172578c4eb09dbfcf1657d43198de59b6cef4054de385365060ed50c458ac98", size = 135255, upload-time = "2025-12-06T15:54:37.209Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/fb/f05646c43d5450492cb387de5549f6de90a71001682c17882d9f66476af5/orjson-3.11.5-cp312-cp312-win_amd64.whl", hash = "sha256:2b91126e7b470ff2e75746f6f6ee32b9ab67b7a93c8ba1d15d3a0caaf16ec875", size = 133252, upload-time = "2025-12-06T15:54:38.401Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/a6/7b8c0b26ba18c793533ac1cd145e131e46fcf43952aa94c109b5b913c1f0/orjson-3.11.5-cp312-cp312-win_arm64.whl", hash = "sha256:acbc5fac7e06777555b0722b8ad5f574739e99ffe99467ed63da98f97f9ca0fe", size = 126777, upload-time = "2025-12-06T15:54:39.515Z" },
-    { url = "https://files.pythonhosted.org/packages/10/43/61a77040ce59f1569edf38f0b9faadc90c8cf7e9bec2e0df51d0132c6bb7/orjson-3.11.5-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:3b01799262081a4c47c035dd77c1301d40f568f77cc7ec1bb7db5d63b0a01629", size = 245271, upload-time = "2025-12-06T15:54:40.878Z" },
-    { url = "https://files.pythonhosted.org/packages/55/f9/0f79be617388227866d50edd2fd320cb8fb94dc1501184bb1620981a0aba/orjson-3.11.5-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:61de247948108484779f57a9f406e4c84d636fa5a59e411e6352484985e8a7c3", size = 129422, upload-time = "2025-12-06T15:54:42.403Z" },
-    { url = "https://files.pythonhosted.org/packages/77/42/f1bf1549b432d4a78bfa95735b79b5dac75b65b5bb815bba86ad406ead0a/orjson-3.11.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:894aea2e63d4f24a7f04a1908307c738d0dce992e9249e744b8f4e8dd9197f39", size = 132060, upload-time = "2025-12-06T15:54:43.531Z" },
-    { url = "https://files.pythonhosted.org/packages/25/49/825aa6b929f1a6ed244c78acd7b22c1481fd7e5fda047dc8bf4c1a807eb6/orjson-3.11.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ddc21521598dbe369d83d4d40338e23d4101dad21dae0e79fa20465dbace019f", size = 130391, upload-time = "2025-12-06T15:54:45.059Z" },
-    { url = "https://files.pythonhosted.org/packages/42/ec/de55391858b49e16e1aa8f0bbbb7e5997b7345d8e984a2dec3746d13065b/orjson-3.11.5-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7cce16ae2f5fb2c53c3eafdd1706cb7b6530a67cc1c17abe8ec747f5cd7c0c51", size = 135964, upload-time = "2025-12-06T15:54:46.576Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/40/820bc63121d2d28818556a2d0a09384a9f0262407cf9fa305e091a8048df/orjson-3.11.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e46c762d9f0e1cfb4ccc8515de7f349abbc95b59cb5a2bd68df5973fdef913f8", size = 139817, upload-time = "2025-12-06T15:54:48.084Z" },
-    { url = "https://files.pythonhosted.org/packages/09/c7/3a445ca9a84a0d59d26365fd8898ff52bdfcdcb825bcc6519830371d2364/orjson-3.11.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d7345c759276b798ccd6d77a87136029e71e66a8bbf2d2755cbdde1d82e78706", size = 137336, upload-time = "2025-12-06T15:54:49.426Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/b3/dc0d3771f2e5d1f13368f56b339c6782f955c6a20b50465a91acb79fe961/orjson-3.11.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75bc2e59e6a2ac1dd28901d07115abdebc4563b5b07dd612bf64260a201b1c7f", size = 138993, upload-time = "2025-12-06T15:54:50.939Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/a2/65267e959de6abe23444659b6e19c888f242bf7725ff927e2292776f6b89/orjson-3.11.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:54aae9b654554c3b4edd61896b978568c6daa16af96fa4681c9b5babd469f863", size = 141070, upload-time = "2025-12-06T15:54:52.414Z" },
-    { url = "https://files.pythonhosted.org/packages/63/c9/da44a321b288727a322c6ab17e1754195708786a04f4f9d2220a5076a649/orjson-3.11.5-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:4bdd8d164a871c4ec773f9de0f6fe8769c2d6727879c37a9666ba4183b7f8228", size = 413505, upload-time = "2025-12-06T15:54:53.67Z" },
-    { url = "https://files.pythonhosted.org/packages/7f/17/68dc14fa7000eefb3d4d6d7326a190c99bb65e319f02747ef3ebf2452f12/orjson-3.11.5-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:a261fef929bcf98a60713bf5e95ad067cea16ae345d9a35034e73c3990e927d2", size = 151342, upload-time = "2025-12-06T15:54:55.113Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/c5/ccee774b67225bed630a57478529fc026eda33d94fe4c0eac8fe58d4aa52/orjson-3.11.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c028a394c766693c5c9909dec76b24f37e6a1b91999e8d0c0d5feecbe93c3e05", size = 141823, upload-time = "2025-12-06T15:54:56.331Z" },
-    { url = "https://files.pythonhosted.org/packages/67/80/5d00e4155d0cd7390ae2087130637671da713959bb558db9bac5e6f6b042/orjson-3.11.5-cp313-cp313-win32.whl", hash = "sha256:2cc79aaad1dfabe1bd2d50ee09814a1253164b3da4c00a78c458d82d04b3bdef", size = 135236, upload-time = "2025-12-06T15:54:57.507Z" },
-    { url = "https://files.pythonhosted.org/packages/95/fe/792cc06a84808dbdc20ac6eab6811c53091b42f8e51ecebf14b540e9cfe4/orjson-3.11.5-cp313-cp313-win_amd64.whl", hash = "sha256:ff7877d376add4e16b274e35a3f58b7f37b362abf4aa31863dadacdd20e3a583", size = 133167, upload-time = "2025-12-06T15:54:58.71Z" },
-    { url = "https://files.pythonhosted.org/packages/46/2c/d158bd8b50e3b1cfdcf406a7e463f6ffe3f0d167b99634717acdaf5e299f/orjson-3.11.5-cp313-cp313-win_arm64.whl", hash = "sha256:59ac72ea775c88b163ba8d21b0177628bd015c5dd060647bbab6e22da3aad287", size = 126712, upload-time = "2025-12-06T15:54:59.892Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/60/77d7b839e317ead7bb225d55bb50f7ea75f47afc489c81199befc5435b50/orjson-3.11.5-cp314-cp314-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:e446a8ea0a4c366ceafc7d97067bfd55292969143b57e3c846d87fc701e797a0", size = 245252, upload-time = "2025-12-06T15:55:01.127Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/aa/d4639163b400f8044cef0fb9aa51b0337be0da3a27187a20d1166e742370/orjson-3.11.5-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:53deb5addae9c22bbe3739298f5f2196afa881ea75944e7720681c7080909a81", size = 129419, upload-time = "2025-12-06T15:55:02.723Z" },
-    { url = "https://files.pythonhosted.org/packages/30/94/9eabf94f2e11c671111139edf5ec410d2f21e6feee717804f7e8872d883f/orjson-3.11.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:82cd00d49d6063d2b8791da5d4f9d20539c5951f965e45ccf4e96d33505ce68f", size = 132050, upload-time = "2025-12-06T15:55:03.918Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/c8/ca10f5c5322f341ea9a9f1097e140be17a88f88d1cfdd29df522970d9744/orjson-3.11.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3fd15f9fc8c203aeceff4fda211157fad114dde66e92e24097b3647a08f4ee9e", size = 130370, upload-time = "2025-12-06T15:55:05.173Z" },
-    { url = "https://files.pythonhosted.org/packages/25/d4/e96824476d361ee2edd5c6290ceb8d7edf88d81148a6ce172fc00278ca7f/orjson-3.11.5-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9df95000fbe6777bf9820ae82ab7578e8662051bb5f83d71a28992f539d2cda7", size = 136012, upload-time = "2025-12-06T15:55:06.402Z" },
-    { url = "https://files.pythonhosted.org/packages/85/8e/9bc3423308c425c588903f2d103cfcfe2539e07a25d6522900645a6f257f/orjson-3.11.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:92a8d676748fca47ade5bc3da7430ed7767afe51b2f8100e3cd65e151c0eaceb", size = 139809, upload-time = "2025-12-06T15:55:07.656Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/3c/b404e94e0b02a232b957c54643ce68d0268dacb67ac33ffdee24008c8b27/orjson-3.11.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:aa0f513be38b40234c77975e68805506cad5d57b3dfd8fe3baa7f4f4051e15b4", size = 137332, upload-time = "2025-12-06T15:55:08.961Z" },
-    { url = "https://files.pythonhosted.org/packages/51/30/cc2d69d5ce0ad9b84811cdf4a0cd5362ac27205a921da524ff42f26d65e0/orjson-3.11.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa1863e75b92891f553b7922ce4ee10ed06db061e104f2b7815de80cdcb135ad", size = 138983, upload-time = "2025-12-06T15:55:10.595Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/87/de3223944a3e297d4707d2fe3b1ffb71437550e165eaf0ca8bbe43ccbcb1/orjson-3.11.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d4be86b58e9ea262617b8ca6251a2f0d63cc132a6da4b5fcc8e0a4128782c829", size = 141069, upload-time = "2025-12-06T15:55:11.832Z" },
-    { url = "https://files.pythonhosted.org/packages/65/30/81d5087ae74be33bcae3ff2d80f5ccaa4a8fedc6d39bf65a427a95b8977f/orjson-3.11.5-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:b923c1c13fa02084eb38c9c065afd860a5cff58026813319a06949c3af5732ac", size = 413491, upload-time = "2025-12-06T15:55:13.314Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/6f/f6058c21e2fc1efaf918986dbc2da5cd38044f1a2d4b7b91ad17c4acf786/orjson-3.11.5-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:1b6bd351202b2cd987f35a13b5e16471cf4d952b42a73c391cc537974c43ef6d", size = 151375, upload-time = "2025-12-06T15:55:14.715Z" },
-    { url = "https://files.pythonhosted.org/packages/54/92/c6921f17d45e110892899a7a563a925b2273d929959ce2ad89e2525b885b/orjson-3.11.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:bb150d529637d541e6af06bbe3d02f5498d628b7f98267ff87647584293ab439", size = 141850, upload-time = "2025-12-06T15:55:15.94Z" },
-    { url = "https://files.pythonhosted.org/packages/88/86/cdecb0140a05e1a477b81f24739da93b25070ee01ce7f7242f44a6437594/orjson-3.11.5-cp314-cp314-win32.whl", hash = "sha256:9cc1e55c884921434a84a0c3dd2699eb9f92e7b441d7f53f3941079ec6ce7499", size = 135278, upload-time = "2025-12-06T15:55:17.202Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/97/b638d69b1e947d24f6109216997e38922d54dcdcdb1b11c18d7efd2d3c59/orjson-3.11.5-cp314-cp314-win_amd64.whl", hash = "sha256:a4f3cb2d874e03bc7767c8f88adaa1a9a05cecea3712649c3b58589ec7317310", size = 133170, upload-time = "2025-12-06T15:55:18.468Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/dd/f4fff4a6fe601b4f8f3ba3aa6da8ac33d17d124491a3b804c662a70e1636/orjson-3.11.5-cp314-cp314-win_arm64.whl", hash = "sha256:38b22f476c351f9a1c43e5b07d8b5a02eb24a6ab8e75f700f7d479d4568346a5", size = 126713, upload-time = "2025-12-06T15:55:19.738Z" },
+    { url = "https://files.pythonhosted.org/packages/de/1a/a373746fa6d0e116dd9e54371a7b54622c44d12296d5d0f3ad5e3ff33490/orjson-3.11.7-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:a02c833f38f36546ba65a452127633afce4cf0dd7296b753d3bb54e55e5c0174", size = 229140, upload-time = "2026-02-02T15:37:06.082Z" },
+    { url = "https://files.pythonhosted.org/packages/52/a2/fa129e749d500f9b183e8a3446a193818a25f60261e9ce143ad61e975208/orjson-3.11.7-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b63c6e6738d7c3470ad01601e23376aa511e50e1f3931395b9f9c722406d1a67", size = 128670, upload-time = "2026-02-02T15:37:08.002Z" },
+    { url = "https://files.pythonhosted.org/packages/08/93/1e82011cd1e0bd051ef9d35bed1aa7fb4ea1f0a055dc2c841b46b43a9ebd/orjson-3.11.7-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:043d3006b7d32c7e233b8cfb1f01c651013ea079e08dcef7189a29abd8befe11", size = 123832, upload-time = "2026-02-02T15:37:09.191Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/d8/a26b431ef962c7d55736674dddade876822f3e33223c1f47a36879350d04/orjson-3.11.7-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:57036b27ac8a25d81112eb0cc9835cd4833c5b16e1467816adc0015f59e870dc", size = 129171, upload-time = "2026-02-02T15:37:11.112Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/19/f47819b84a580f490da260c3ee9ade214cf4cf78ac9ce8c1c758f80fdfc9/orjson-3.11.7-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:733ae23ada68b804b222c44affed76b39e30806d38660bf1eb200520d259cc16", size = 141967, upload-time = "2026-02-02T15:37:12.282Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/cd/37ece39a0777ba077fdcdbe4cccae3be8ed00290c14bf8afdc548befc260/orjson-3.11.7-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5fdfad2093bdd08245f2e204d977facd5f871c88c4a71230d5bcbd0e43bf6222", size = 130991, upload-time = "2026-02-02T15:37:13.465Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/ed/f2b5d66aa9b6b5c02ff5f120efc7b38c7c4962b21e6be0f00fd99a5c348e/orjson-3.11.7-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cededd6738e1c153530793998e31c05086582b08315db48ab66649768f326baa", size = 133674, upload-time = "2026-02-02T15:37:14.694Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/6e/baa83e68d1aa09fa8c3e5b2c087d01d0a0bd45256de719ed7bc22c07052d/orjson-3.11.7-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:14f440c7268c8f8633d1b3d443a434bd70cb15686117ea6beff8fdc8f5917a1e", size = 138722, upload-time = "2026-02-02T15:37:16.501Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/47/7f8ef4963b772cd56999b535e553f7eb5cd27e9dd6c049baee6f18bfa05d/orjson-3.11.7-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:3a2479753bbb95b0ebcf7969f562cdb9668e6d12416a35b0dda79febf89cdea2", size = 409056, upload-time = "2026-02-02T15:37:17.895Z" },
+    { url = "https://files.pythonhosted.org/packages/38/eb/2df104dd2244b3618f25325a656f85cc3277f74bbd91224752410a78f3c7/orjson-3.11.7-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:71924496986275a737f38e3f22b4e0878882b3f7a310d2ff4dc96e812789120c", size = 144196, upload-time = "2026-02-02T15:37:19.349Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/2a/ee41de0aa3a6686598661eae2b4ebdff1340c65bfb17fcff8b87138aab21/orjson-3.11.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b4a9eefdc70bf8bf9857f0290f973dec534ac84c35cd6a7f4083be43e7170a8f", size = 134979, upload-time = "2026-02-02T15:37:20.906Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/fa/92fc5d3d402b87a8b28277a9ed35386218a6a5287c7fe5ee9b9f02c53fb2/orjson-3.11.7-cp310-cp310-win32.whl", hash = "sha256:ae9e0b37a834cef7ce8f99de6498f8fad4a2c0bf6bfc3d02abd8ed56aa15b2de", size = 127968, upload-time = "2026-02-02T15:37:23.178Z" },
+    { url = "https://files.pythonhosted.org/packages/07/29/a576bf36d73d60df06904d3844a9df08e25d59eba64363aaf8ec2f9bff41/orjson-3.11.7-cp310-cp310-win_amd64.whl", hash = "sha256:d772afdb22555f0c58cfc741bdae44180122b3616faa1ecadb595cd526e4c993", size = 125128, upload-time = "2026-02-02T15:37:24.329Z" },
+    { url = "https://files.pythonhosted.org/packages/37/02/da6cb01fc6087048d7f61522c327edf4250f1683a58a839fdcc435746dd5/orjson-3.11.7-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:9487abc2c2086e7c8eb9a211d2ce8855bae0e92586279d0d27b341d5ad76c85c", size = 228664, upload-time = "2026-02-02T15:37:25.542Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/c2/5885e7a5881dba9a9af51bc564e8967225a642b3e03d089289a35054e749/orjson-3.11.7-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:79cacb0b52f6004caf92405a7e1f11e6e2de8bdf9019e4f76b44ba045125cd6b", size = 125344, upload-time = "2026-02-02T15:37:26.92Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/1d/4e7688de0a92d1caf600dfd5fb70b4c5bfff51dfa61ac555072ef2d0d32a/orjson-3.11.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c2e85fe4698b6a56d5e2ebf7ae87544d668eb6bde1ad1226c13f44663f20ec9e", size = 128404, upload-time = "2026-02-02T15:37:28.108Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/b2/ec04b74ae03a125db7bd69cffd014b227b7f341e3261bf75b5eb88a1aa92/orjson-3.11.7-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b8d14b71c0b12963fe8a62aac87119f1afdf4cb88a400f61ca5ae581449efcb5", size = 123677, upload-time = "2026-02-02T15:37:30.287Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/69/f95bdf960605f08f827f6e3291fe243d8aa9c5c9ff017a8d7232209184c3/orjson-3.11.7-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:91c81ef070c8f3220054115e1ef468b1c9ce8497b4e526cb9f68ab4dc0a7ac62", size = 128950, upload-time = "2026-02-02T15:37:31.595Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/1b/de59c57bae1d148ef298852abd31909ac3089cff370dfd4cd84cc99cbc42/orjson-3.11.7-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:411ebaf34d735e25e358a6d9e7978954a9c9d58cfb47bc6683cdc3964cd2f910", size = 141756, upload-time = "2026-02-02T15:37:32.985Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/9e/9decc59f4499f695f65c650f6cfa6cd4c37a3fbe8fa235a0a3614cb54386/orjson-3.11.7-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a16bcd08ab0bcdfc7e8801d9c4a9cc17e58418e4d48ddc6ded4e9e4b1a94062b", size = 130812, upload-time = "2026-02-02T15:37:34.204Z" },
+    { url = "https://files.pythonhosted.org/packages/28/e6/59f932bcabd1eac44e334fe8e3281a92eacfcb450586e1f4bde0423728d8/orjson-3.11.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c0b51672e466fd7e56230ffbae7f1639e18d0ce023351fb75da21b71bc2c960", size = 133444, upload-time = "2026-02-02T15:37:35.446Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/36/b0f05c0eaa7ca30bc965e37e6a2956b0d67adb87a9872942d3568da846ae/orjson-3.11.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:136dcd6a2e796dfd9ffca9fc027d778567b0b7c9968d092842d3c323cef88aa8", size = 138609, upload-time = "2026-02-02T15:37:36.657Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/03/58ec7d302b8d86944c60c7b4b82975d5161fcce4c9bc8c6cb1d6741b6115/orjson-3.11.7-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:7ba61079379b0ae29e117db13bda5f28d939766e410d321ec1624afc6a0b0504", size = 408918, upload-time = "2026-02-02T15:37:38.076Z" },
+    { url = "https://files.pythonhosted.org/packages/06/3a/868d65ef9a8b99be723bd510de491349618abd9f62c826cf206d962db295/orjson-3.11.7-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0527a4510c300e3b406591b0ba69b5dc50031895b0a93743526a3fc45f59d26e", size = 143998, upload-time = "2026-02-02T15:37:39.706Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/c7/1e18e1c83afe3349f4f6dc9e14910f0ae5f82eac756d1412ea4018938535/orjson-3.11.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a709e881723c9b18acddcfb8ba357322491ad553e277cf467e1e7e20e2d90561", size = 134802, upload-time = "2026-02-02T15:37:41.002Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/0b/ccb7ee1a65b37e8eeb8b267dc953561d72370e85185e459616d4345bab34/orjson-3.11.7-cp311-cp311-win32.whl", hash = "sha256:c43b8b5bab288b6b90dac410cca7e986a4fa747a2e8f94615aea407da706980d", size = 127828, upload-time = "2026-02-02T15:37:42.241Z" },
+    { url = "https://files.pythonhosted.org/packages/af/9e/55c776dffda3f381e0f07d010a4f5f3902bf48eaba1bb7684d301acd4924/orjson-3.11.7-cp311-cp311-win_amd64.whl", hash = "sha256:6543001328aa857187f905308a028935864aefe9968af3848401b6fe80dbb471", size = 124941, upload-time = "2026-02-02T15:37:43.444Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/8e/424a620fa7d263b880162505fb107ef5e0afaa765b5b06a88312ac291560/orjson-3.11.7-cp311-cp311-win_arm64.whl", hash = "sha256:1ee5cc7160a821dfe14f130bc8e63e7611051f964b463d9e2a3a573204446a4d", size = 126245, upload-time = "2026-02-02T15:37:45.18Z" },
+    { url = "https://files.pythonhosted.org/packages/80/bf/76f4f1665f6983385938f0e2a5d7efa12a58171b8456c252f3bae8a4cf75/orjson-3.11.7-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:bd03ea7606833655048dab1a00734a2875e3e86c276e1d772b2a02556f0d895f", size = 228545, upload-time = "2026-02-02T15:37:46.376Z" },
+    { url = "https://files.pythonhosted.org/packages/79/53/6c72c002cb13b5a978a068add59b25a8bdf2800ac1c9c8ecdb26d6d97064/orjson-3.11.7-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:89e440ebc74ce8ab5c7bc4ce6757b4a6b1041becb127df818f6997b5c71aa60b", size = 125224, upload-time = "2026-02-02T15:37:47.697Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/83/10e48852865e5dd151bdfe652c06f7da484578ed02c5fca938e3632cb0b8/orjson-3.11.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5ede977b5fe5ac91b1dffc0a517ca4542d2ec8a6a4ff7b2652d94f640796342a", size = 128154, upload-time = "2026-02-02T15:37:48.954Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/52/a66e22a2b9abaa374b4a081d410edab6d1e30024707b87eab7c734afe28d/orjson-3.11.7-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b7b1dae39230a393df353827c855a5f176271c23434cfd2db74e0e424e693e10", size = 123548, upload-time = "2026-02-02T15:37:50.187Z" },
+    { url = "https://files.pythonhosted.org/packages/de/38/605d371417021359f4910c496f764c48ceb8997605f8c25bf1dfe58c0ebe/orjson-3.11.7-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ed46f17096e28fb28d2975834836a639af7278aa87c84f68ab08fbe5b8bd75fa", size = 129000, upload-time = "2026-02-02T15:37:51.426Z" },
+    { url = "https://files.pythonhosted.org/packages/44/98/af32e842b0ffd2335c89714d48ca4e3917b42f5d6ee5537832e069a4b3ac/orjson-3.11.7-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3726be79e36e526e3d9c1aceaadbfb4a04ee80a72ab47b3f3c17fefb9812e7b8", size = 141686, upload-time = "2026-02-02T15:37:52.607Z" },
+    { url = "https://files.pythonhosted.org/packages/96/0b/fc793858dfa54be6feee940c1463370ece34b3c39c1ca0aa3845f5ba9892/orjson-3.11.7-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0724e265bc548af1dedebd9cb3d24b4e1c1e685a343be43e87ba922a5c5fff2f", size = 130812, upload-time = "2026-02-02T15:37:53.944Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/91/98a52415059db3f374757d0b7f0f16e3b5cd5976c90d1c2b56acaea039e6/orjson-3.11.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e7745312efa9e11c17fbd3cb3097262d079da26930ae9ae7ba28fb738367cbad", size = 133440, upload-time = "2026-02-02T15:37:55.615Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/b6/cb540117bda61791f46381f8c26c8f93e802892830a6055748d3bb1925ab/orjson-3.11.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f904c24bdeabd4298f7a977ef14ca2a022ca921ed670b92ecd16ab6f3d01f867", size = 138386, upload-time = "2026-02-02T15:37:56.814Z" },
+    { url = "https://files.pythonhosted.org/packages/63/1a/50a3201c334a7f17c231eee5f841342190723794e3b06293f26e7cf87d31/orjson-3.11.7-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b9fc4d0f81f394689e0814617aadc4f2ea0e8025f38c226cbf22d3b5ddbf025d", size = 408853, upload-time = "2026-02-02T15:37:58.291Z" },
+    { url = "https://files.pythonhosted.org/packages/87/cd/8de1c67d0be44fdc22701e5989c0d015a2adf391498ad42c4dc589cd3013/orjson-3.11.7-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:849e38203e5be40b776ed2718e587faf204d184fc9a008ae441f9442320c0cab", size = 144130, upload-time = "2026-02-02T15:38:00.163Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/fe/d605d700c35dd55f51710d159fc54516a280923cd1b7e47508982fbb387d/orjson-3.11.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4682d1db3bcebd2b64757e0ddf9e87ae5f00d29d16c5cdf3a62f561d08cc3dd2", size = 134818, upload-time = "2026-02-02T15:38:01.507Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/e4/15ecc67edb3ddb3e2f46ae04475f2d294e8b60c1825fbe28a428b93b3fbd/orjson-3.11.7-cp312-cp312-win32.whl", hash = "sha256:f4f7c956b5215d949a1f65334cf9d7612dde38f20a95f2315deef167def91a6f", size = 127923, upload-time = "2026-02-02T15:38:02.75Z" },
+    { url = "https://files.pythonhosted.org/packages/34/70/2e0855361f76198a3965273048c8e50a9695d88cd75811a5b46444895845/orjson-3.11.7-cp312-cp312-win_amd64.whl", hash = "sha256:bf742e149121dc5648ba0a08ea0871e87b660467ef168a3a5e53bc1fbd64bb74", size = 125007, upload-time = "2026-02-02T15:38:04.032Z" },
+    { url = "https://files.pythonhosted.org/packages/68/40/c2051bd19fc467610fed469dc29e43ac65891571138f476834ca192bc290/orjson-3.11.7-cp312-cp312-win_arm64.whl", hash = "sha256:26c3b9132f783b7d7903bf1efb095fed8d4a3a85ec0d334ee8beff3d7a4749d5", size = 126089, upload-time = "2026-02-02T15:38:05.297Z" },
+    { url = "https://files.pythonhosted.org/packages/89/25/6e0e52cac5aab51d7b6dcd257e855e1dec1c2060f6b28566c509b4665f62/orjson-3.11.7-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:1d98b30cc1313d52d4af17d9c3d307b08389752ec5f2e5febdfada70b0f8c733", size = 228390, upload-time = "2026-02-02T15:38:06.8Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/29/a77f48d2fc8a05bbc529e5ff481fb43d914f9e383ea2469d4f3d51df3d00/orjson-3.11.7-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:d897e81f8d0cbd2abb82226d1860ad2e1ab3ff16d7b08c96ca00df9d45409ef4", size = 125189, upload-time = "2026-02-02T15:38:08.181Z" },
+    { url = "https://files.pythonhosted.org/packages/89/25/0a16e0729a0e6a1504f9d1a13cdd365f030068aab64cec6958396b9969d7/orjson-3.11.7-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:814be4b49b228cfc0b3c565acf642dd7d13538f966e3ccde61f4f55be3e20785", size = 128106, upload-time = "2026-02-02T15:38:09.41Z" },
+    { url = "https://files.pythonhosted.org/packages/66/da/a2e505469d60666a05ab373f1a6322eb671cb2ba3a0ccfc7d4bc97196787/orjson-3.11.7-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d06e5c5fed5caedd2e540d62e5b1c25e8c82431b9e577c33537e5fa4aa909539", size = 123363, upload-time = "2026-02-02T15:38:10.73Z" },
+    { url = "https://files.pythonhosted.org/packages/23/bf/ed73f88396ea35c71b38961734ea4a4746f7ca0768bf28fd551d37e48dd0/orjson-3.11.7-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:31c80ce534ac4ea3739c5ee751270646cbc46e45aea7576a38ffec040b4029a1", size = 129007, upload-time = "2026-02-02T15:38:12.138Z" },
+    { url = "https://files.pythonhosted.org/packages/73/3c/b05d80716f0225fc9008fbf8ab22841dcc268a626aa550561743714ce3bf/orjson-3.11.7-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f50979824bde13d32b4320eedd513431c921102796d86be3eee0b58e58a3ecd1", size = 141667, upload-time = "2026-02-02T15:38:13.398Z" },
+    { url = "https://files.pythonhosted.org/packages/61/e8/0be9b0addd9bf86abfc938e97441dcd0375d494594b1c8ad10fe57479617/orjson-3.11.7-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9e54f3808e2b6b945078c41aa8d9b5834b28c50843846e97807e5adb75fa9705", size = 130832, upload-time = "2026-02-02T15:38:14.698Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/ec/c68e3b9021a31d9ec15a94931db1410136af862955854ed5dd7e7e4f5bff/orjson-3.11.7-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a12b80df61aab7b98b490fe9e4879925ba666fccdfcd175252ce4d9035865ace", size = 133373, upload-time = "2026-02-02T15:38:16.109Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/45/f3466739aaafa570cc8e77c6dbb853c48bf56e3b43738020e2661e08b0ac/orjson-3.11.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:996b65230271f1a97026fd0e6a753f51fbc0c335d2ad0c6201f711b0da32693b", size = 138307, upload-time = "2026-02-02T15:38:17.453Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/84/9f7f02288da1ffb31405c1be07657afd1eecbcb4b64ee2817b6fe0f785fa/orjson-3.11.7-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ab49d4b2a6a1d415ddb9f37a21e02e0d5dbfe10b7870b21bf779fc21e9156157", size = 408695, upload-time = "2026-02-02T15:38:18.831Z" },
+    { url = "https://files.pythonhosted.org/packages/18/07/9dd2f0c0104f1a0295ffbe912bc8d63307a539b900dd9e2c48ef7810d971/orjson-3.11.7-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:390a1dce0c055ddf8adb6aa94a73b45a4a7d7177b5c584b8d1c1947f2ba60fb3", size = 144099, upload-time = "2026-02-02T15:38:20.28Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/66/857a8e4a3292e1f7b1b202883bcdeb43a91566cf59a93f97c53b44bd6801/orjson-3.11.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1eb80451a9c351a71dfaf5b7ccc13ad065405217726b59fdbeadbcc544f9d223", size = 134806, upload-time = "2026-02-02T15:38:22.186Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/5b/6ebcf3defc1aab3a338ca777214966851e92efb1f30dc7fc8285216e6d1b/orjson-3.11.7-cp313-cp313-win32.whl", hash = "sha256:7477aa6a6ec6139c5cb1cc7b214643592169a5494d200397c7fc95d740d5fcf3", size = 127914, upload-time = "2026-02-02T15:38:23.511Z" },
+    { url = "https://files.pythonhosted.org/packages/00/04/c6f72daca5092e3117840a1b1e88dfc809cc1470cf0734890d0366b684a1/orjson-3.11.7-cp313-cp313-win_amd64.whl", hash = "sha256:b9f95dcdea9d4f805daa9ddf02617a89e484c6985fa03055459f90e87d7a0757", size = 124986, upload-time = "2026-02-02T15:38:24.836Z" },
+    { url = "https://files.pythonhosted.org/packages/03/ba/077a0f6f1085d6b806937246860fafbd5b17f3919c70ee3f3d8d9c713f38/orjson-3.11.7-cp313-cp313-win_arm64.whl", hash = "sha256:800988273a014a0541483dc81021247d7eacb0c845a9d1a34a422bc718f41539", size = 126045, upload-time = "2026-02-02T15:38:26.216Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/1e/745565dca749813db9a093c5ebc4bac1a9475c64d54b95654336ac3ed961/orjson-3.11.7-cp314-cp314-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:de0a37f21d0d364954ad5de1970491d7fbd0fb1ef7417d4d56a36dc01ba0c0a0", size = 228391, upload-time = "2026-02-02T15:38:27.757Z" },
+    { url = "https://files.pythonhosted.org/packages/46/19/e40f6225da4d3aa0c8dc6e5219c5e87c2063a560fe0d72a88deb59776794/orjson-3.11.7-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:c2428d358d85e8da9d37cba18b8c4047c55222007a84f97156a5b22028dfbfc0", size = 125188, upload-time = "2026-02-02T15:38:29.241Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/7e/c4de2babef2c0817fd1f048fd176aa48c37bec8aef53d2fa932983032cce/orjson-3.11.7-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3c4bc6c6ac52cdaa267552544c73e486fecbd710b7ac09bc024d5a78555a22f6", size = 128097, upload-time = "2026-02-02T15:38:30.618Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/74/233d360632bafd2197f217eee7fb9c9d0229eac0c18128aee5b35b0014fe/orjson-3.11.7-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bd0d68edd7dfca1b2eca9361a44ac9f24b078de3481003159929a0573f21a6bf", size = 123364, upload-time = "2026-02-02T15:38:32.363Z" },
+    { url = "https://files.pythonhosted.org/packages/79/51/af79504981dd31efe20a9e360eb49c15f06df2b40e7f25a0a52d9ae888e8/orjson-3.11.7-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:623ad1b9548ef63886319c16fa317848e465a21513b31a6ad7b57443c3e0dcf5", size = 129076, upload-time = "2026-02-02T15:38:33.68Z" },
+    { url = "https://files.pythonhosted.org/packages/67/e2/da898eb68b72304f8de05ca6715870d09d603ee98d30a27e8a9629abc64b/orjson-3.11.7-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6e776b998ac37c0396093d10290e60283f59cfe0fc3fccbd0ccc4bd04dd19892", size = 141705, upload-time = "2026-02-02T15:38:34.989Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/89/15364d92acb3d903b029e28d834edb8780c2b97404cbf7929aa6b9abdb24/orjson-3.11.7-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:652c6c3af76716f4a9c290371ba2e390ede06f6603edb277b481daf37f6f464e", size = 130855, upload-time = "2026-02-02T15:38:36.379Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/8b/ecdad52d0b38d4b8f514be603e69ccd5eacf4e7241f972e37e79792212ec/orjson-3.11.7-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a56df3239294ea5964adf074c54bcc4f0ccd21636049a2cf3ca9cf03b5d03cf1", size = 133386, upload-time = "2026-02-02T15:38:37.704Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/0e/45e1dcf10e17d0924b7c9162f87ec7b4ca79e28a0548acf6a71788d3e108/orjson-3.11.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:bda117c4148e81f746655d5a3239ae9bd00cb7bc3ca178b5fc5a5997e9744183", size = 138295, upload-time = "2026-02-02T15:38:39.096Z" },
+    { url = "https://files.pythonhosted.org/packages/63/d7/4d2e8b03561257af0450f2845b91fbd111d7e526ccdf737267108075e0ba/orjson-3.11.7-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:23d6c20517a97a9daf1d48b580fcdc6f0516c6f4b5038823426033690b4d2650", size = 408720, upload-time = "2026-02-02T15:38:40.634Z" },
+    { url = "https://files.pythonhosted.org/packages/78/cf/d45343518282108b29c12a65892445fc51f9319dc3c552ceb51bb5905ed2/orjson-3.11.7-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:8ff206156006da5b847c9304b6308a01e8cdbc8cce824e2779a5ba71c3def141", size = 144152, upload-time = "2026-02-02T15:38:42.262Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/3a/d6001f51a7275aacd342e77b735c71fa04125a3f93c36fee4526bc8c654e/orjson-3.11.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:962d046ee1765f74a1da723f4b33e3b228fe3a48bd307acce5021dfefe0e29b2", size = 134814, upload-time = "2026-02-02T15:38:43.627Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/d3/f19b47ce16820cc2c480f7f1723e17f6d411b3a295c60c8ad3aa9ff1c96a/orjson-3.11.7-cp314-cp314-win32.whl", hash = "sha256:89e13dd3f89f1c38a9c9eba5fbf7cdc2d1feca82f5f290864b4b7a6aac704576", size = 127997, upload-time = "2026-02-02T15:38:45.06Z" },
+    { url = "https://files.pythonhosted.org/packages/12/df/172771902943af54bf661a8d102bdf2e7f932127968080632bda6054b62c/orjson-3.11.7-cp314-cp314-win_amd64.whl", hash = "sha256:845c3e0d8ded9c9271cd79596b9b552448b885b97110f628fb687aee2eed11c1", size = 124985, upload-time = "2026-02-02T15:38:46.388Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/1c/f2a8d8a1b17514660a614ce5f7aac74b934e69f5abc2700cc7ced882a009/orjson-3.11.7-cp314-cp314-win_arm64.whl", hash = "sha256:4a2e9c5be347b937a2e0203866f12bba36082e89b402ddb9e927d5822e43088d", size = 126038, upload-time = "2026-02-02T15:38:47.703Z" },
 ]
 
 [[package]]
@@ -1073,28 +1073,27 @@ wheels = [
 
 [[package]]
 name = "ruff"
-version = "0.14.13"
+version = "0.15.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/50/0a/1914efb7903174b381ee2ffeebb4253e729de57f114e63595114c8ca451f/ruff-0.14.13.tar.gz", hash = "sha256:83cd6c0763190784b99650a20fec7633c59f6ebe41c5cc9d45ee42749563ad47", size = 6059504, upload-time = "2026-01-15T20:15:16.918Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/dc/4e6ac71b511b141cf626357a3946679abeba4cf67bc7cc5a17920f31e10d/ruff-0.15.1.tar.gz", hash = "sha256:c590fe13fb57c97141ae975c03a1aedb3d3156030cabd740d6ff0b0d601e203f", size = 4540855, upload-time = "2026-02-12T23:09:09.998Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c3/ae/0deefbc65ca74b0ab1fd3917f94dc3b398233346a74b8bbb0a916a1a6bf6/ruff-0.14.13-py3-none-linux_armv6l.whl", hash = "sha256:76f62c62cd37c276cb03a275b198c7c15bd1d60c989f944db08a8c1c2dbec18b", size = 13062418, upload-time = "2026-01-15T20:14:50.779Z" },
-    { url = "https://files.pythonhosted.org/packages/47/df/5916604faa530a97a3c154c62a81cb6b735c0cb05d1e26d5ad0f0c8ac48a/ruff-0.14.13-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:914a8023ece0528d5cc33f5a684f5f38199bbb566a04815c2c211d8f40b5d0ed", size = 13442344, upload-time = "2026-01-15T20:15:07.94Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/f3/e0e694dd69163c3a1671e102aa574a50357536f18a33375050334d5cd517/ruff-0.14.13-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d24899478c35ebfa730597a4a775d430ad0d5631b8647a3ab368c29b7e7bd063", size = 12354720, upload-time = "2026-01-15T20:15:09.854Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/e8/67f5fcbbaee25e8fc3b56cc33e9892eca7ffe09f773c8e5907757a7e3bdb/ruff-0.14.13-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9aaf3870f14d925bbaf18b8a2347ee0ae7d95a2e490e4d4aea6813ed15ebc80e", size = 12774493, upload-time = "2026-01-15T20:15:20.908Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/ce/d2e9cb510870b52a9565d885c0d7668cc050e30fa2c8ac3fb1fda15c083d/ruff-0.14.13-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac5b7f63dd3b27cc811850f5ffd8fff845b00ad70e60b043aabf8d6ecc304e09", size = 12815174, upload-time = "2026-01-15T20:15:05.74Z" },
-    { url = "https://files.pythonhosted.org/packages/88/00/c38e5da58beebcf4fa32d0ddd993b63dfacefd02ab7922614231330845bf/ruff-0.14.13-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:78d2b1097750d90ba82ce4ba676e85230a0ed694178ca5e61aa9b459970b3eb9", size = 13680909, upload-time = "2026-01-15T20:15:14.537Z" },
-    { url = "https://files.pythonhosted.org/packages/61/61/cd37c9dd5bd0a3099ba79b2a5899ad417d8f3b04038810b0501a80814fd7/ruff-0.14.13-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:7d0bf87705acbbcb8d4c24b2d77fbb73d40210a95c3903b443cd9e30824a5032", size = 15144215, upload-time = "2026-01-15T20:15:22.886Z" },
-    { url = "https://files.pythonhosted.org/packages/56/8a/85502d7edbf98c2df7b8876f316c0157359165e16cdf98507c65c8d07d3d/ruff-0.14.13-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a3eb5da8e2c9e9f13431032fdcbe7681de9ceda5835efee3269417c13f1fed5c", size = 14706067, upload-time = "2026-01-15T20:14:48.271Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/2f/de0df127feb2ee8c1e54354dc1179b4a23798f0866019528c938ba439aca/ruff-0.14.13-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:642442b42957093811cd8d2140dfadd19c7417030a7a68cf8d51fcdd5f217427", size = 14133916, upload-time = "2026-01-15T20:14:57.357Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/77/9b99686bb9fe07a757c82f6f95e555c7a47801a9305576a9c67e0a31d280/ruff-0.14.13-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4acdf009f32b46f6e8864af19cbf6841eaaed8638e65c8dac845aea0d703c841", size = 13859207, upload-time = "2026-01-15T20:14:55.111Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/46/2bdcb34a87a179a4d23022d818c1c236cb40e477faf0d7c9afb6813e5876/ruff-0.14.13-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:591a7f68860ea4e003917d19b5c4f5ac39ff558f162dc753a2c5de897fd5502c", size = 14043686, upload-time = "2026-01-15T20:14:52.841Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/a9/5c6a4f56a0512c691cf143371bcf60505ed0f0860f24a85da8bd123b2bf1/ruff-0.14.13-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:774c77e841cc6e046fc3e91623ce0903d1cd07e3a36b1a9fe79b81dab3de506b", size = 12663837, upload-time = "2026-01-15T20:15:18.921Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/bb/b920016ece7651fa7fcd335d9d199306665486694d4361547ccb19394c44/ruff-0.14.13-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:61f4e40077a1248436772bb6512db5fc4457fe4c49e7a94ea7c5088655dd21ae", size = 12805867, upload-time = "2026-01-15T20:14:59.272Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/b3/0bd909851e5696cd21e32a8fc25727e5f58f1934b3596975503e6e85415c/ruff-0.14.13-py3-none-musllinux_1_2_i686.whl", hash = "sha256:6d02f1428357fae9e98ac7aa94b7e966fd24151088510d32cf6f902d6c09235e", size = 13208528, upload-time = "2026-01-15T20:15:03.732Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/3b/e2d94cb613f6bbd5155a75cbe072813756363eba46a3f2177a1fcd0cd670/ruff-0.14.13-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e399341472ce15237be0c0ae5fbceca4b04cd9bebab1a2b2c979e015455d8f0c", size = 13929242, upload-time = "2026-01-15T20:15:11.918Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/c5/abd840d4132fd51a12f594934af5eba1d5d27298a6f5b5d6c3be45301caf/ruff-0.14.13-py3-none-win32.whl", hash = "sha256:ef720f529aec113968b45dfdb838ac8934e519711da53a0456038a0efecbd680", size = 12919024, upload-time = "2026-01-15T20:14:43.647Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/55/6384b0b8ce731b6e2ade2b5449bf07c0e4c31e8a2e68ea65b3bafadcecc5/ruff-0.14.13-py3-none-win_amd64.whl", hash = "sha256:6070bd026e409734b9257e03e3ef18c6e1a216f0435c6751d7a8ec69cb59abef", size = 14097887, upload-time = "2026-01-15T20:15:01.48Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/e1/7348090988095e4e39560cfc2f7555b1b2a7357deba19167b600fdf5215d/ruff-0.14.13-py3-none-win_arm64.whl", hash = "sha256:7ab819e14f1ad9fe39f246cfcc435880ef7a9390d81a2b6ac7e01039083dd247", size = 13080224, upload-time = "2026-01-15T20:14:45.853Z" },
+    { url = "https://files.pythonhosted.org/packages/23/bf/e6e4324238c17f9d9120a9d60aa99a7daaa21204c07fcd84e2ef03bb5fd1/ruff-0.15.1-py3-none-linux_armv6l.whl", hash = "sha256:b101ed7cf4615bda6ffe65bdb59f964e9f4a0d3f85cbf0e54f0ab76d7b90228a", size = 10367819, upload-time = "2026-02-12T23:09:03.598Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/ea/c8f89d32e7912269d38c58f3649e453ac32c528f93bb7f4219258be2e7ed/ruff-0.15.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:939c995e9277e63ea632cc8d3fae17aa758526f49a9a850d2e7e758bfef46602", size = 10798618, upload-time = "2026-02-12T23:09:22.928Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/0f/1d0d88bc862624247d82c20c10d4c0f6bb2f346559d8af281674cf327f15/ruff-0.15.1-py3-none-macosx_11_0_arm64.whl", hash = "sha256:1d83466455fdefe60b8d9c8df81d3c1bbb2115cede53549d3b522ce2bc703899", size = 10148518, upload-time = "2026-02-12T23:08:58.339Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/c8/291c49cefaa4a9248e986256df2ade7add79388fe179e0691be06fae6f37/ruff-0.15.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9457e3c3291024866222b96108ab2d8265b477e5b1534c7ddb1810904858d16", size = 10518811, upload-time = "2026-02-12T23:09:31.865Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/1a/f5707440e5ae43ffa5365cac8bbb91e9665f4a883f560893829cf16a606b/ruff-0.15.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:92c92b003e9d4f7fbd33b1867bb15a1b785b1735069108dfc23821ba045b29bc", size = 10196169, upload-time = "2026-02-12T23:09:17.306Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/ff/26ddc8c4da04c8fd3ee65a89c9fb99eaa5c30394269d424461467be2271f/ruff-0.15.1-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fe5c41ab43e3a06778844c586251eb5a510f67125427625f9eb2b9526535779", size = 10990491, upload-time = "2026-02-12T23:09:25.503Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/00/50920cb385b89413f7cdb4bb9bc8fc59c1b0f30028d8bccc294189a54955/ruff-0.15.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66a6dd6df4d80dc382c6484f8ce1bcceb55c32e9f27a8b94c32f6c7331bf14fb", size = 11843280, upload-time = "2026-02-12T23:09:19.88Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/6d/2f5cad8380caf5632a15460c323ae326f1e1a2b5b90a6ee7519017a017ca/ruff-0.15.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6a4a42cbb8af0bda9bcd7606b064d7c0bc311a88d141d02f78920be6acb5aa83", size = 11274336, upload-time = "2026-02-12T23:09:14.907Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/1d/5f56cae1d6c40b8a318513599b35ea4b075d7dc1cd1d04449578c29d1d75/ruff-0.15.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4ab064052c31dddada35079901592dfba2e05f5b1e43af3954aafcbc1096a5b2", size = 11137288, upload-time = "2026-02-12T23:09:07.475Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/20/6f8d7d8f768c93b0382b33b9306b3b999918816da46537d5a61635514635/ruff-0.15.1-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:5631c940fe9fe91f817a4c2ea4e81f47bee3ca4aa646134a24374f3c19ad9454", size = 11070681, upload-time = "2026-02-12T23:08:55.43Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/67/d640ac76069f64cdea59dba02af2e00b1fa30e2103c7f8d049c0cff4cafd/ruff-0.15.1-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:68138a4ba184b4691ccdc39f7795c66b3c68160c586519e7e8444cf5a53e1b4c", size = 10486401, upload-time = "2026-02-12T23:09:27.927Z" },
+    { url = "https://files.pythonhosted.org/packages/65/3d/e1429f64a3ff89297497916b88c32a5cc88eeca7e9c787072d0e7f1d3e1e/ruff-0.15.1-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:518f9af03bfc33c03bdb4cb63fabc935341bb7f54af500f92ac309ecfbba6330", size = 10197452, upload-time = "2026-02-12T23:09:12.147Z" },
+    { url = "https://files.pythonhosted.org/packages/78/83/e2c3bade17dad63bf1e1c2ffaf11490603b760be149e1419b07049b36ef2/ruff-0.15.1-py3-none-musllinux_1_2_i686.whl", hash = "sha256:da79f4d6a826caaea95de0237a67e33b81e6ec2e25fc7e1993a4015dffca7c61", size = 10693900, upload-time = "2026-02-12T23:09:34.418Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/27/fdc0e11a813e6338e0706e8b39bb7a1d61ea5b36873b351acee7e524a72a/ruff-0.15.1-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:3dd86dccb83cd7d4dcfac303ffc277e6048600dfc22e38158afa208e8bf94a1f", size = 11227302, upload-time = "2026-02-12T23:09:36.536Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/58/ac864a75067dcbd3b95be5ab4eb2b601d7fbc3d3d736a27e391a4f92a5c1/ruff-0.15.1-py3-none-win32.whl", hash = "sha256:660975d9cb49b5d5278b12b03bb9951d554543a90b74ed5d366b20e2c57c2098", size = 10462555, upload-time = "2026-02-12T23:09:29.899Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/5e/d4ccc8a27ecdb78116feac4935dfc39d1304536f4296168f91ed3ec00cd2/ruff-0.15.1-py3-none-win_amd64.whl", hash = "sha256:c820fef9dd5d4172a6570e5721704a96c6679b80cf7be41659ed439653f62336", size = 11599956, upload-time = "2026-02-12T23:09:01.157Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/07/5bda6a85b220c64c65686bc85bd0bbb23b29c62b3a9f9433fa55f17cda93/ruff-0.15.1-py3-none-win_arm64.whl", hash = "sha256:5ff7d5f0f88567850f45081fac8f4ec212be8d0b963e385c3f7d0d2eb4899416", size = 10874604, upload-time = "2026-02-12T23:09:05.515Z" },
 ]
 
 [[package]]

libs/checkpoint-sqlite/uv.lock

@@ -249,7 +249,7 @@ wheels = [
 
 [[package]]
 name = "langchain-core"
-version = "1.2.7"
+version = "1.2.11"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jsonpatch" },
@@ -261,9 +261,9 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "uuid-utils" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a2/0e/664d8d81b3493e09cbab72448d2f9d693d1fa5aa2bcc488602203a9b6da0/langchain_core-1.2.7.tar.gz", hash = "sha256:e1460639f96c352b4a41c375f25aeb8d16ffc1769499fb1c20503aad59305ced", size = 837039, upload-time = "2026-01-09T17:44:25.505Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/12/17/1943cedfc118e04b8128e4c3e1dbf0fa0ea58eefddbb6198cfd699d19f01/langchain_core-1.2.11.tar.gz", hash = "sha256:f164bb36602dd74a3a50c1334fca75309ad5ed95767acdfdbb9fa95ce28a1e01", size = 831211, upload-time = "2026-02-10T20:35:28.35Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6e/6f/34a9fba14d191a67f7e2ee3dbce3e9b86d2fa7310e2c7f2c713583481bd2/langchain_core-1.2.7-py3-none-any.whl", hash = "sha256:452f4fef7a3d883357b22600788d37e3d8854ef29da345b7ac7099f33c31828b", size = 490232, upload-time = "2026-01-09T17:44:24.236Z" },
+    { url = "https://files.pythonhosted.org/packages/10/30/1f80e3fc674353cad975ed5294353d42512535d2094ef032c06454c2c873/langchain_core-1.2.11-py3-none-any.whl", hash = "sha256:ae11ceb8dda60d0b9d09e763116e592f1683327c17be5b715f350fd29aee65d3", size = 500062, upload-time = "2026-02-10T20:35:26.698Z" },
 ]
 
 [[package]]
@@ -997,28 +997,27 @@ wheels = [
 
 [[package]]
 name = "ruff"
-version = "0.14.13"
+version = "0.15.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/50/0a/1914efb7903174b381ee2ffeebb4253e729de57f114e63595114c8ca451f/ruff-0.14.13.tar.gz", hash = "sha256:83cd6c0763190784b99650a20fec7633c59f6ebe41c5cc9d45ee42749563ad47", size = 6059504, upload-time = "2026-01-15T20:15:16.918Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/dc/4e6ac71b511b141cf626357a3946679abeba4cf67bc7cc5a17920f31e10d/ruff-0.15.1.tar.gz", hash = "sha256:c590fe13fb57c97141ae975c03a1aedb3d3156030cabd740d6ff0b0d601e203f", size = 4540855, upload-time = "2026-02-12T23:09:09.998Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c3/ae/0deefbc65ca74b0ab1fd3917f94dc3b398233346a74b8bbb0a916a1a6bf6/ruff-0.14.13-py3-none-linux_armv6l.whl", hash = "sha256:76f62c62cd37c276cb03a275b198c7c15bd1d60c989f944db08a8c1c2dbec18b", size = 13062418, upload-time = "2026-01-15T20:14:50.779Z" },
-    { url = "https://files.pythonhosted.org/packages/47/df/5916604faa530a97a3c154c62a81cb6b735c0cb05d1e26d5ad0f0c8ac48a/ruff-0.14.13-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:914a8023ece0528d5cc33f5a684f5f38199bbb566a04815c2c211d8f40b5d0ed", size = 13442344, upload-time = "2026-01-15T20:15:07.94Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/f3/e0e694dd69163c3a1671e102aa574a50357536f18a33375050334d5cd517/ruff-0.14.13-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d24899478c35ebfa730597a4a775d430ad0d5631b8647a3ab368c29b7e7bd063", size = 12354720, upload-time = "2026-01-15T20:15:09.854Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/e8/67f5fcbbaee25e8fc3b56cc33e9892eca7ffe09f773c8e5907757a7e3bdb/ruff-0.14.13-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9aaf3870f14d925bbaf18b8a2347ee0ae7d95a2e490e4d4aea6813ed15ebc80e", size = 12774493, upload-time = "2026-01-15T20:15:20.908Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/ce/d2e9cb510870b52a9565d885c0d7668cc050e30fa2c8ac3fb1fda15c083d/ruff-0.14.13-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac5b7f63dd3b27cc811850f5ffd8fff845b00ad70e60b043aabf8d6ecc304e09", size = 12815174, upload-time = "2026-01-15T20:15:05.74Z" },
-    { url = "https://files.pythonhosted.org/packages/88/00/c38e5da58beebcf4fa32d0ddd993b63dfacefd02ab7922614231330845bf/ruff-0.14.13-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:78d2b1097750d90ba82ce4ba676e85230a0ed694178ca5e61aa9b459970b3eb9", size = 13680909, upload-time = "2026-01-15T20:15:14.537Z" },
-    { url = "https://files.pythonhosted.org/packages/61/61/cd37c9dd5bd0a3099ba79b2a5899ad417d8f3b04038810b0501a80814fd7/ruff-0.14.13-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:7d0bf87705acbbcb8d4c24b2d77fbb73d40210a95c3903b443cd9e30824a5032", size = 15144215, upload-time = "2026-01-15T20:15:22.886Z" },
-    { url = "https://files.pythonhosted.org/packages/56/8a/85502d7edbf98c2df7b8876f316c0157359165e16cdf98507c65c8d07d3d/ruff-0.14.13-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a3eb5da8e2c9e9f13431032fdcbe7681de9ceda5835efee3269417c13f1fed5c", size = 14706067, upload-time = "2026-01-15T20:14:48.271Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/2f/de0df127feb2ee8c1e54354dc1179b4a23798f0866019528c938ba439aca/ruff-0.14.13-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:642442b42957093811cd8d2140dfadd19c7417030a7a68cf8d51fcdd5f217427", size = 14133916, upload-time = "2026-01-15T20:14:57.357Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/77/9b99686bb9fe07a757c82f6f95e555c7a47801a9305576a9c67e0a31d280/ruff-0.14.13-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4acdf009f32b46f6e8864af19cbf6841eaaed8638e65c8dac845aea0d703c841", size = 13859207, upload-time = "2026-01-15T20:14:55.111Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/46/2bdcb34a87a179a4d23022d818c1c236cb40e477faf0d7c9afb6813e5876/ruff-0.14.13-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:591a7f68860ea4e003917d19b5c4f5ac39ff558f162dc753a2c5de897fd5502c", size = 14043686, upload-time = "2026-01-15T20:14:52.841Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/a9/5c6a4f56a0512c691cf143371bcf60505ed0f0860f24a85da8bd123b2bf1/ruff-0.14.13-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:774c77e841cc6e046fc3e91623ce0903d1cd07e3a36b1a9fe79b81dab3de506b", size = 12663837, upload-time = "2026-01-15T20:15:18.921Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/bb/b920016ece7651fa7fcd335d9d199306665486694d4361547ccb19394c44/ruff-0.14.13-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:61f4e40077a1248436772bb6512db5fc4457fe4c49e7a94ea7c5088655dd21ae", size = 12805867, upload-time = "2026-01-15T20:14:59.272Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/b3/0bd909851e5696cd21e32a8fc25727e5f58f1934b3596975503e6e85415c/ruff-0.14.13-py3-none-musllinux_1_2_i686.whl", hash = "sha256:6d02f1428357fae9e98ac7aa94b7e966fd24151088510d32cf6f902d6c09235e", size = 13208528, upload-time = "2026-01-15T20:15:03.732Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/3b/e2d94cb613f6bbd5155a75cbe072813756363eba46a3f2177a1fcd0cd670/ruff-0.14.13-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e399341472ce15237be0c0ae5fbceca4b04cd9bebab1a2b2c979e015455d8f0c", size = 13929242, upload-time = "2026-01-15T20:15:11.918Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/c5/abd840d4132fd51a12f594934af5eba1d5d27298a6f5b5d6c3be45301caf/ruff-0.14.13-py3-none-win32.whl", hash = "sha256:ef720f529aec113968b45dfdb838ac8934e519711da53a0456038a0efecbd680", size = 12919024, upload-time = "2026-01-15T20:14:43.647Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/55/6384b0b8ce731b6e2ade2b5449bf07c0e4c31e8a2e68ea65b3bafadcecc5/ruff-0.14.13-py3-none-win_amd64.whl", hash = "sha256:6070bd026e409734b9257e03e3ef18c6e1a216f0435c6751d7a8ec69cb59abef", size = 14097887, upload-time = "2026-01-15T20:15:01.48Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/e1/7348090988095e4e39560cfc2f7555b1b2a7357deba19167b600fdf5215d/ruff-0.14.13-py3-none-win_arm64.whl", hash = "sha256:7ab819e14f1ad9fe39f246cfcc435880ef7a9390d81a2b6ac7e01039083dd247", size = 13080224, upload-time = "2026-01-15T20:14:45.853Z" },
+    { url = "https://files.pythonhosted.org/packages/23/bf/e6e4324238c17f9d9120a9d60aa99a7daaa21204c07fcd84e2ef03bb5fd1/ruff-0.15.1-py3-none-linux_armv6l.whl", hash = "sha256:b101ed7cf4615bda6ffe65bdb59f964e9f4a0d3f85cbf0e54f0ab76d7b90228a", size = 10367819, upload-time = "2026-02-12T23:09:03.598Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/ea/c8f89d32e7912269d38c58f3649e453ac32c528f93bb7f4219258be2e7ed/ruff-0.15.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:939c995e9277e63ea632cc8d3fae17aa758526f49a9a850d2e7e758bfef46602", size = 10798618, upload-time = "2026-02-12T23:09:22.928Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/0f/1d0d88bc862624247d82c20c10d4c0f6bb2f346559d8af281674cf327f15/ruff-0.15.1-py3-none-macosx_11_0_arm64.whl", hash = "sha256:1d83466455fdefe60b8d9c8df81d3c1bbb2115cede53549d3b522ce2bc703899", size = 10148518, upload-time = "2026-02-12T23:08:58.339Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/c8/291c49cefaa4a9248e986256df2ade7add79388fe179e0691be06fae6f37/ruff-0.15.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9457e3c3291024866222b96108ab2d8265b477e5b1534c7ddb1810904858d16", size = 10518811, upload-time = "2026-02-12T23:09:31.865Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/1a/f5707440e5ae43ffa5365cac8bbb91e9665f4a883f560893829cf16a606b/ruff-0.15.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:92c92b003e9d4f7fbd33b1867bb15a1b785b1735069108dfc23821ba045b29bc", size = 10196169, upload-time = "2026-02-12T23:09:17.306Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/ff/26ddc8c4da04c8fd3ee65a89c9fb99eaa5c30394269d424461467be2271f/ruff-0.15.1-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fe5c41ab43e3a06778844c586251eb5a510f67125427625f9eb2b9526535779", size = 10990491, upload-time = "2026-02-12T23:09:25.503Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/00/50920cb385b89413f7cdb4bb9bc8fc59c1b0f30028d8bccc294189a54955/ruff-0.15.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66a6dd6df4d80dc382c6484f8ce1bcceb55c32e9f27a8b94c32f6c7331bf14fb", size = 11843280, upload-time = "2026-02-12T23:09:19.88Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/6d/2f5cad8380caf5632a15460c323ae326f1e1a2b5b90a6ee7519017a017ca/ruff-0.15.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6a4a42cbb8af0bda9bcd7606b064d7c0bc311a88d141d02f78920be6acb5aa83", size = 11274336, upload-time = "2026-02-12T23:09:14.907Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/1d/5f56cae1d6c40b8a318513599b35ea4b075d7dc1cd1d04449578c29d1d75/ruff-0.15.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4ab064052c31dddada35079901592dfba2e05f5b1e43af3954aafcbc1096a5b2", size = 11137288, upload-time = "2026-02-12T23:09:07.475Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/20/6f8d7d8f768c93b0382b33b9306b3b999918816da46537d5a61635514635/ruff-0.15.1-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:5631c940fe9fe91f817a4c2ea4e81f47bee3ca4aa646134a24374f3c19ad9454", size = 11070681, upload-time = "2026-02-12T23:08:55.43Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/67/d640ac76069f64cdea59dba02af2e00b1fa30e2103c7f8d049c0cff4cafd/ruff-0.15.1-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:68138a4ba184b4691ccdc39f7795c66b3c68160c586519e7e8444cf5a53e1b4c", size = 10486401, upload-time = "2026-02-12T23:09:27.927Z" },
+    { url = "https://files.pythonhosted.org/packages/65/3d/e1429f64a3ff89297497916b88c32a5cc88eeca7e9c787072d0e7f1d3e1e/ruff-0.15.1-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:518f9af03bfc33c03bdb4cb63fabc935341bb7f54af500f92ac309ecfbba6330", size = 10197452, upload-time = "2026-02-12T23:09:12.147Z" },
+    { url = "https://files.pythonhosted.org/packages/78/83/e2c3bade17dad63bf1e1c2ffaf11490603b760be149e1419b07049b36ef2/ruff-0.15.1-py3-none-musllinux_1_2_i686.whl", hash = "sha256:da79f4d6a826caaea95de0237a67e33b81e6ec2e25fc7e1993a4015dffca7c61", size = 10693900, upload-time = "2026-02-12T23:09:34.418Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/27/fdc0e11a813e6338e0706e8b39bb7a1d61ea5b36873b351acee7e524a72a/ruff-0.15.1-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:3dd86dccb83cd7d4dcfac303ffc277e6048600dfc22e38158afa208e8bf94a1f", size = 11227302, upload-time = "2026-02-12T23:09:36.536Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/58/ac864a75067dcbd3b95be5ab4eb2b601d7fbc3d3d736a27e391a4f92a5c1/ruff-0.15.1-py3-none-win32.whl", hash = "sha256:660975d9cb49b5d5278b12b03bb9951d554543a90b74ed5d366b20e2c57c2098", size = 10462555, upload-time = "2026-02-12T23:09:29.899Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/5e/d4ccc8a27ecdb78116feac4935dfc39d1304536f4296168f91ed3ec00cd2/ruff-0.15.1-py3-none-win_amd64.whl", hash = "sha256:c820fef9dd5d4172a6570e5721704a96c6679b80cf7be41659ed439653f62336", size = 11599956, upload-time = "2026-02-12T23:09:01.157Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/07/5bda6a85b220c64c65686bc85bd0bbb23b29c62b3a9f9433fa55f17cda93/ruff-0.15.1-py3-none-win_arm64.whl", hash = "sha256:5ff7d5f0f88567850f45081fac8f4ec212be8d0b963e385c3f7d0d2eb4899416", size = 10874604, upload-time = "2026-02-12T23:09:05.515Z" },
 ]
 
 [[package]]

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

@@ -51,6 +51,8 @@ class CheckpointMetadata(TypedDict, total=False):
 
     Mapping from checkpoint namespace to checkpoint ID.
     """
+    run_id: str
+    """The ID of the run that created this checkpoint."""
 
 
 ChannelVersions = dict[str, str | int | float]
@@ -268,6 +270,45 @@ class BaseCheckpointSaver(Generic[V]):
         """
         raise NotImplementedError
 
+    def delete_for_runs(
+        self,
+        run_ids: Sequence[str],
+    ) -> None:
+        """Delete all checkpoints and writes associated with the given run IDs.
+
+        Args:
+            run_ids: The run IDs whose checkpoints should be deleted.
+        """
+        raise NotImplementedError
+
+    def copy_thread(
+        self,
+        source_thread_id: str,
+        target_thread_id: str,
+    ) -> None:
+        """Copy all checkpoints and writes from one thread to another.
+
+        Args:
+            source_thread_id: The thread ID to copy from.
+            target_thread_id: The thread ID to copy to.
+        """
+        raise NotImplementedError
+
+    def prune(
+        self,
+        thread_ids: Sequence[str],
+        *,
+        strategy: str = "keep_latest",
+    ) -> None:
+        """Prune checkpoints for the given threads.
+
+        Args:
+            thread_ids: The thread IDs to prune.
+            strategy: The pruning strategy. `"keep_latest"` retains only the most
+                recent checkpoint per namespace. `"delete"` removes all checkpoints.
+        """
+        raise NotImplementedError
+
     async def aget(self, config: RunnableConfig) -> Checkpoint | None:
         """Asynchronously fetch a checkpoint using the given configuration.
 
@@ -373,6 +414,45 @@ class BaseCheckpointSaver(Generic[V]):
         """
         raise NotImplementedError
 
+    async def adelete_for_runs(
+        self,
+        run_ids: Sequence[str],
+    ) -> None:
+        """Asynchronously delete all checkpoints and writes for the given run IDs.
+
+        Args:
+            run_ids: The run IDs whose checkpoints should be deleted.
+        """
+        raise NotImplementedError
+
+    async def acopy_thread(
+        self,
+        source_thread_id: str,
+        target_thread_id: str,
+    ) -> None:
+        """Asynchronously copy all checkpoints and writes from one thread to another.
+
+        Args:
+            source_thread_id: The thread ID to copy from.
+            target_thread_id: The thread ID to copy to.
+        """
+        raise NotImplementedError
+
+    async def aprune(
+        self,
+        thread_ids: Sequence[str],
+        *,
+        strategy: str = "keep_latest",
+    ) -> None:
+        """Asynchronously prune checkpoints for the given threads.
+
+        Args:
+            thread_ids: The thread IDs to prune.
+            strategy: The pruning strategy. `"keep_latest"` retains only the most
+                recent checkpoint per namespace. `"delete"` removes all checkpoints.
+        """
+        raise NotImplementedError
+
     def get_next_version(self, current: V | None, channel: None) -> V:
         """Generate the next version ID for a channel.
 

libs/checkpoint/uv.lock

@@ -267,7 +267,7 @@ wheels = [
 
 [[package]]
 name = "langchain-core"
-version = "1.2.7"
+version = "1.2.12"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jsonpatch" },
@@ -279,9 +279,9 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "uuid-utils" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a2/0e/664d8d81b3493e09cbab72448d2f9d693d1fa5aa2bcc488602203a9b6da0/langchain_core-1.2.7.tar.gz", hash = "sha256:e1460639f96c352b4a41c375f25aeb8d16ffc1769499fb1c20503aad59305ced", size = 837039, upload-time = "2026-01-09T17:44:25.505Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2a/1d/08e935d1532fcc90981f6e5bb6825914c9227ea7a962c62b1e18619b49e7/langchain_core-1.2.12.tar.gz", hash = "sha256:4d7fa6643d7ab06fc1905a9b7dcbe96a6f3c181046b56edf9c0c17ecd412d9e9", size = 831329, upload-time = "2026-02-12T20:53:15.01Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6e/6f/34a9fba14d191a67f7e2ee3dbce3e9b86d2fa7310e2c7f2c713583481bd2/langchain_core-1.2.7-py3-none-any.whl", hash = "sha256:452f4fef7a3d883357b22600788d37e3d8854ef29da345b7ac7099f33c31828b", size = 490232, upload-time = "2026-01-09T17:44:24.236Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/a5/678ab0e5cc57794f20ae5ed12c1442506ef1108c9434f950aebc6044e5a3/langchain_core-1.2.12-py3-none-any.whl", hash = "sha256:66ca17a2a9cb007ab29021968e6adfcf4228067151dc2bd6ebfff265ffaf92f5", size = 500132, upload-time = "2026-02-12T20:53:13.806Z" },
 ]
 
 [[package]]
@@ -755,57 +755,58 @@ wheels = [
 
 [[package]]
 name = "ormsgpack"
-version = "1.12.1"
+version = "1.12.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/fe/96/34c40d621996c2f377a18decbd3c59f031dde73c3ba47d1e1e8f29a05aaa/ormsgpack-1.12.1.tar.gz", hash = "sha256:a3877fde1e4f27a39f92681a0aab6385af3a41d0c25375d33590ae20410ea2ac", size = 39476, upload-time = "2025-12-14T07:57:43.248Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/12/0c/f1761e21486942ab9bb6feaebc610fa074f7c5e496e6962dea5873348077/ormsgpack-1.12.2.tar.gz", hash = "sha256:944a2233640273bee67521795a73cf1e959538e0dfb7ac635505010455e53b33", size = 39031, upload-time = "2026-01-18T20:55:28.023Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b5/da/caf25cc54d6870089a0b5614c4c5914dd3fae45f9f7f84a32445ad0612e3/ormsgpack-1.12.1-cp310-cp310-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:62e3614cab63fa5aa42f5f0ca3cd12899f0bfc5eb8a5a0ebab09d571c89d427d", size = 376182, upload-time = "2025-12-14T07:56:46.094Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/02/ccc9170c6bee86f428707f15b5ad68d42c71d43856e1b8e37cdfea50af5b/ormsgpack-1.12.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:86d9fbf85c05c69c33c229d2eba7c8c3500a56596cd8348131c918acd040d6af", size = 202339, upload-time = "2025-12-14T07:56:47.609Z" },
-    { url = "https://files.pythonhosted.org/packages/86/c7/10309a5a6421adaedab710a72470143d664bb0a043cc095c1311878325a0/ormsgpack-1.12.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8d246e66f09d8e0f96e770829149ee83206e90ed12f5987998bb7be84aec99fe", size = 210720, upload-time = "2025-12-14T07:56:48.66Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/b4/92a0f7a00c5f0c71b51dc3112e53b1ca937b9891a08979d06524db11b799/ormsgpack-1.12.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cfc2c830a1ed2d00de713d08c9e62efa699e8fd29beafa626aaebe466f583ebb", size = 211264, upload-time = "2025-12-14T07:56:49.976Z" },
-    { url = "https://files.pythonhosted.org/packages/33/fa/5cce85c8e58fcaa048c75fbbe37816a1b3fb58ba4289a7dedc4f4ed9ce82/ormsgpack-1.12.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:bc892757d8f9eea5208268a527cf93c98409802f6a9f7c8d71a7b8f9ba5cb944", size = 386076, upload-time = "2025-12-14T07:56:51.74Z" },
-    { url = "https://files.pythonhosted.org/packages/88/d0/f18d258c733eb22eadad748659f7984d0b6a851fb3deefcb33f50e9a947a/ormsgpack-1.12.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:0de1dbcf11ea739ac4a882b43d5c2055e6d99ce64e8d6502e25d6d881700c017", size = 479570, upload-time = "2025-12-14T07:56:52.912Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/3a/b362dff090f4740090fe51d512f24b1e320d1f96497ebf9248e2a04ac88f/ormsgpack-1.12.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:d5065dfb9ec4db93241c60847624d9aeef4ccb449c26a018c216b55c69be83c0", size = 387859, upload-time = "2025-12-14T07:56:53.968Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/8a/d948965598b2b7872800076da5c02573aa72f716be57a3d4fe60490b2a2a/ormsgpack-1.12.1-cp310-cp310-win_amd64.whl", hash = "sha256:7d17103c4726181d7000c61b751c881f1b6f401d146df12da028fc730227df19", size = 115906, upload-time = "2025-12-14T07:56:55.068Z" },
-    { url = "https://files.pythonhosted.org/packages/57/e2/f5b89365c8dc8025c27d31316038f1c103758ddbf87dc0fa8e3f78f66907/ormsgpack-1.12.1-cp311-cp311-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:4038f59ae0e19dac5e5d9aae4ec17ff84a79e046342ee73ccdecf3547ecf0d34", size = 376180, upload-time = "2025-12-14T07:56:56.521Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/87/3f694e06f5e32c6d65066f53b4a025282a5072b6b336c17560b00e04606d/ormsgpack-1.12.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:16c63b0c5a3eec467e4bb33a14dabba076b7d934dff62898297b5c0b5f7c3cb3", size = 202338, upload-time = "2025-12-14T07:56:57.585Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/f5/6d95d7b7c11f97a92522082fc7e5d1ab34537929f1e13f4c369f392f19d0/ormsgpack-1.12.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:74fd6a8e037eb310dda865298e8d122540af00fe5658ec18b97a1d34f4012e4d", size = 210720, upload-time = "2025-12-14T07:56:58.968Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/9d/9a49a2686f8b7165dcb2342b8554951263c30c0f0825f1fcc2d56e736a6b/ormsgpack-1.12.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58ad60308e233dd824a1859eabb5fe092e123e885eafa4ad5789322329c80fb5", size = 211264, upload-time = "2025-12-14T07:57:00.099Z" },
-    { url = "https://files.pythonhosted.org/packages/02/31/2fdc36eaeca2182900b96fc7b19755f293283fe681750e3d295733d62f0e/ormsgpack-1.12.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:35127464c941c1219acbe1a220e48d55e7933373d12257202f4042f7044b4c90", size = 386081, upload-time = "2025-12-14T07:57:01.177Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/65/0a765432f08ae26b4013c6a9aed97be17a9ef85f1600948a474b518e27dd/ormsgpack-1.12.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:c48d1c50794692d1e6e3f8c3bb65f5c3acfaae9347e506484a65d60b3d91fb50", size = 479572, upload-time = "2025-12-14T07:57:02.738Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/4f/f2f15ebef786ad71cea420bf8692448fbddf04d1bf3feaa68bd5ee3172e6/ormsgpack-1.12.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b512b2ad6feaaefdc26e05431ed2843e42483041e354e167c53401afaa83d919", size = 387862, upload-time = "2025-12-14T07:57:03.842Z" },
-    { url = "https://files.pythonhosted.org/packages/15/eb/86fbef1d605fa91ecef077f93f9d0e34fc39b23475dfe3ffb92f6c8db28d/ormsgpack-1.12.1-cp311-cp311-win_amd64.whl", hash = "sha256:93f30db95e101a9616323bfc50807ad00e7f6197cea2216d2d24af42afc77d88", size = 115900, upload-time = "2025-12-14T07:57:05.137Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/67/7ba1a46e6a6e263fc42a4fafc24afc1ab21a66116553cad670426f0bd9ef/ormsgpack-1.12.1-cp311-cp311-win_arm64.whl", hash = "sha256:d75b5fa14f6abffce2c392ee03b4731199d8a964c81ee8645c4c79af0e80fd50", size = 109868, upload-time = "2025-12-14T07:57:06.834Z" },
-    { url = "https://files.pythonhosted.org/packages/17/fe/ab9167ca037406b5703add24049cf3e18021a3b16133ea20615b1f160ea4/ormsgpack-1.12.1-cp312-cp312-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:4d7fb0e1b6fbc701d75269f7405a4f79230a6ce0063fb1092e4f6577e312f86d", size = 376725, upload-time = "2025-12-14T07:57:07.894Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/ea/2820e65f506894c459b840d1091ae6e327fde3d5a3f3b002a11a1b9bdf7d/ormsgpack-1.12.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:43a9353e2db5b024c91a47d864ef15eaa62d81824cfc7740fed4cef7db738694", size = 202466, upload-time = "2025-12-14T07:57:09.049Z" },
-    { url = "https://files.pythonhosted.org/packages/45/8b/def01c13339c5bbec2ee1469ef53e7fadd66c8d775df974ee4def1572515/ormsgpack-1.12.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fc8fe866b7706fc25af0adf1f600bc06ece5b15ca44e34641327198b821e5c3c", size = 210748, upload-time = "2025-12-14T07:57:10.074Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/d2/bf350c92f7f067dd9484499705f2d8366d8d9008a670e3d1d0add1908f85/ormsgpack-1.12.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:813755b5f598a78242042e05dfd1ada4e769e94b98c9ab82554550f97ff4d641", size = 211510, upload-time = "2025-12-14T07:57:11.165Z" },
-    { url = "https://files.pythonhosted.org/packages/74/92/9d689bcb95304a6da26c4d59439c350940c25d1b35f146d402ccc6344c51/ormsgpack-1.12.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8eea2a13536fae45d78f93f2cc846c9765c7160c85f19cfefecc20873c137cdd", size = 386237, upload-time = "2025-12-14T07:57:12.306Z" },
-    { url = "https://files.pythonhosted.org/packages/17/fe/bd3107547f8b6129265dd957f40b9cd547d2445db2292aacb13335a7ea89/ormsgpack-1.12.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:7a02ebda1a863cbc604740e76faca8eee1add322db2dcbe6cf32669fffdff65c", size = 479589, upload-time = "2025-12-14T07:57:13.475Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/7c/e8e5cc9edb967d44f6f85e9ebdad440b59af3fae00b137a4327dc5aed9bb/ormsgpack-1.12.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3c0bd63897c439931cdf29348e5e6e8c330d529830e848d10767615c0f3d1b82", size = 388077, upload-time = "2025-12-14T07:57:14.551Z" },
-    { url = "https://files.pythonhosted.org/packages/35/6b/5031797e43b58506f28a8760b26dc23f2620fb4f2200c4c1b3045603e67e/ormsgpack-1.12.1-cp312-cp312-win_amd64.whl", hash = "sha256:362f2e812f8d7035dc25a009171e09d7cc97cb30d3c9e75a16aeae00ca3c1dcf", size = 116190, upload-time = "2025-12-14T07:57:15.575Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/fd/9f43ea6425e383a6b2dbfafebb06fd60e8d68c700ef715adfbcdb499f75d/ormsgpack-1.12.1-cp312-cp312-win_arm64.whl", hash = "sha256:6190281e381db2ed0045052208f47a995ccf61eed48f1215ae3cce3fbccd59c5", size = 109990, upload-time = "2025-12-14T07:57:16.419Z" },
-    { url = "https://files.pythonhosted.org/packages/11/42/f110dfe7cf23a52a82e23eb23d9a6a76ae495447d474686dfa758f3d71d6/ormsgpack-1.12.1-cp313-cp313-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:9663d6b3ecc917c063d61a99169ce196a80f3852e541ae404206836749459279", size = 376746, upload-time = "2025-12-14T07:57:17.699Z" },
-    { url = "https://files.pythonhosted.org/packages/11/76/b386e508a8ae207daec240201a81adb26467bf99b163560724e86bd9ff33/ormsgpack-1.12.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:32e85cfbaf01a94a92520e7fe7851cfcfe21a5698299c28ab86194895f9b9233", size = 202489, upload-time = "2025-12-14T07:57:18.807Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/0e/5db7a63f387149024572daa3d9512fe8fb14bf4efa0722d6d491bed280e7/ormsgpack-1.12.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:dabfd2c24b59c7c69870a5ecee480dfae914a42a0c2e7c9d971cf531e2ba471a", size = 210757, upload-time = "2025-12-14T07:57:19.893Z" },
-    { url = "https://files.pythonhosted.org/packages/64/79/3a9899e57cb57430bd766fc1b4c9ad410cb2ba6070bc8cf6301e7d385768/ormsgpack-1.12.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51bbf2b64afeded34ccd8e25402e4bca038757913931fa0d693078d75563f6f9", size = 211518, upload-time = "2025-12-14T07:57:20.972Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/cd/4f41710ae9fe50d7fcbe476793b3c487746d0e1cc194cc0fee42ff6d989b/ormsgpack-1.12.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9959a71dde1bd0ced84af17facc06a8afada495a34e9cb1bad8e9b20d4c59cef", size = 386251, upload-time = "2025-12-14T07:57:22.099Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/54/ba0c97d6231b1f01daafaa520c8cce1e1b7fceaae6fdc1c763925874a7de/ormsgpack-1.12.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:e9be0e3b62d758f21f5b20e0e06b3a240ec546c4a327bf771f5825462aa74714", size = 479607, upload-time = "2025-12-14T07:57:23.525Z" },
-    { url = "https://files.pythonhosted.org/packages/18/75/19a9a97a462776d525baf41cfb7072734528775f0a3d5fbfab3aa7756b9b/ormsgpack-1.12.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a29d49ab7fdd77ea787818e60cb4ef491708105b9c4c9b0f919201625eb036b5", size = 388062, upload-time = "2025-12-14T07:57:24.616Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/6a/ec26e3f44e9632ecd2f43638b7b37b500eaea5d79cab984ad0b94be14f82/ormsgpack-1.12.1-cp313-cp313-win_amd64.whl", hash = "sha256:c418390b47a1d367e803f6c187f77e4d67c7ae07ba962e3a4a019001f4b0291a", size = 116195, upload-time = "2025-12-14T07:57:25.626Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/64/bfa5f4a34d0f15c6aba1b73e73f7441a66d635bd03249d334a4796b7a924/ormsgpack-1.12.1-cp313-cp313-win_arm64.whl", hash = "sha256:cfa22c91cffc10a7fbd43729baff2de7d9c28cef2509085a704168ae31f02568", size = 109986, upload-time = "2025-12-14T07:57:26.569Z" },
-    { url = "https://files.pythonhosted.org/packages/87/0e/78e5697164e3223b9b216c13e99f1acbc1ee9833490d68842b13da8ba883/ormsgpack-1.12.1-cp314-cp314-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:b93c91efb1a70751a1902a5b43b27bd8fd38e0ca0365cf2cde2716423c15c3a6", size = 376758, upload-time = "2025-12-14T07:57:27.641Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/0e/3a3cbb64703263d7bbaed7effa3ce78cb9add360a60aa7c544d7df28b641/ormsgpack-1.12.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3cf0ea0389167b5fa8d2933dd3f33e887ec4ba68f89c25214d7eec4afd746d22", size = 202487, upload-time = "2025-12-14T07:57:29.051Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/2c/807ebe2b77995599bbb1dec8c3f450d5d7dddee14ce3e1e71dc60e2e2a74/ormsgpack-1.12.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f4c29af837f35af3375070689e781161e7cf019eb2f7cd641734ae45cd001c0d", size = 210853, upload-time = "2025-12-14T07:57:30.508Z" },
-    { url = "https://files.pythonhosted.org/packages/25/57/2cdfc354e3ad8e847628f511f4d238799d90e9e090941e50b9d5ba955ae2/ormsgpack-1.12.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:336fc65aa0fe65896a3dabaae31e332a0a98b4a00ad7b0afde21a7505fd23ff3", size = 211545, upload-time = "2025-12-14T07:57:31.585Z" },
-    { url = "https://files.pythonhosted.org/packages/76/1d/c6fda560e4a8ff865b3aec8a86f7c95ab53f4532193a6ae4ab9db35f85aa/ormsgpack-1.12.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:940f60aabfefe71dd6b82cb33f4ff10b2e7f5fcfa5f103cdb0a23b6aae4c713c", size = 386333, upload-time = "2025-12-14T07:57:32.957Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/3e/715081b36fceb8b497c68b87d384e1cc6d9c9c130ce3b435634d3d785b86/ormsgpack-1.12.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:596ad9e1b6d4c95595c54aaf49b1392609ca68f562ce06f4f74a5bc4053bcda4", size = 479701, upload-time = "2025-12-14T07:57:34.686Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/cf/01ad04def42b3970fc1a302c07f4b46339edf62ef9650247097260471f40/ormsgpack-1.12.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:575210e8fcbc7b0375026ba040a5eef223e9f66a4453d9623fc23282ae09c3c8", size = 388148, upload-time = "2025-12-14T07:57:35.771Z" },
-    { url = "https://files.pythonhosted.org/packages/15/91/1fff2fc2b5943c740028f339154e7103c8f2edf1a881d9fbba2ce11c3b1d/ormsgpack-1.12.1-cp314-cp314-win_amd64.whl", hash = "sha256:647daa3718572280893456be44c60aea6690b7f2edc54c55648ee66e8f06550f", size = 116201, upload-time = "2025-12-14T07:57:36.763Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/66/142b542aed3f96002c7d1c33507ca6e1e0d0a42b9253ab27ef7ed5793bd9/ormsgpack-1.12.1-cp314-cp314-win_arm64.whl", hash = "sha256:a8b3ab762a6deaf1b6490ab46dda0c51528cf8037e0246c40875c6fe9e37b699", size = 110029, upload-time = "2025-12-14T07:57:37.703Z" },
-    { url = "https://files.pythonhosted.org/packages/38/b3/ef4494438c90359e1547eaed3c5ec46e2c431d59a3de2af4e70ebd594c49/ormsgpack-1.12.1-cp314-cp314t-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:12087214e436c1f6c28491949571abea759a63111908c4f7266586d78144d7a8", size = 376777, upload-time = "2025-12-14T07:57:38.795Z" },
-    { url = "https://files.pythonhosted.org/packages/05/a0/1149a7163f8b0dfbc64bf9099b6f16d102ad3b03bcc11afee198d751da2d/ormsgpack-1.12.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e6d54c14cf86ef13f10ccade94d1e7de146aa9b17d371e18b16e95f329393b7", size = 202490, upload-time = "2025-12-14T07:57:40.168Z" },
-    { url = "https://files.pythonhosted.org/packages/68/82/f2ec5e758d6a7106645cca9bb7137d98bce5d363789fa94075be6572057c/ormsgpack-1.12.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5f3584d07882b7ea2a1a589f795a3af97fe4c2932b739408e6d1d9d286cad862", size = 211733, upload-time = "2025-12-14T07:57:42.253Z" },
+    { url = "https://files.pythonhosted.org/packages/93/fa/a91f70829ebccf6387c4946e0a1a109f6ba0d6a28d65f628bedfad94b890/ormsgpack-1.12.2-cp310-cp310-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:c1429217f8f4d7fcb053523bbbac6bed5e981af0b85ba616e6df7cce53c19657", size = 378262, upload-time = "2026-01-18T20:55:22.284Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/62/3698a9a0c487252b5c6a91926e5654e79e665708ea61f67a8bdeceb022bf/ormsgpack-1.12.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5f13034dc6c84a6280c6c33db7ac420253852ea233fc3ee27c8875f8dd651163", size = 203034, upload-time = "2026-01-18T20:55:53.324Z" },
+    { url = "https://files.pythonhosted.org/packages/66/3a/f716f64edc4aec2744e817660b317e2f9bb8de372338a95a96198efa1ac1/ormsgpack-1.12.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:59f5da97000c12bc2d50e988bdc8576b21f6ab4e608489879d35b2c07a8ab51a", size = 210538, upload-time = "2026-01-18T20:55:20.097Z" },
+    { url = "https://files.pythonhosted.org/packages/72/30/a436be9ce27d693d4e19fa94900028067133779f09fc45776db3f689c822/ormsgpack-1.12.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e4459c3f27066beadb2b81ea48a076a417aafffff7df1d3c11c519190ed44f2", size = 212401, upload-time = "2026-01-18T20:55:46.447Z" },
+    { url = "https://files.pythonhosted.org/packages/10/c5/cde98300fd33fee84ca71de4751b19aeeca675f0cf3c0ec4b043f40f3b76/ormsgpack-1.12.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7a1c460655d7288407ffa09065e322a7231997c0d62ce914bf3a96ad2dc6dedd", size = 387080, upload-time = "2026-01-18T20:56:00.884Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/31/30bf445ef827546747c10889dd254b3d84f92b591300efe4979d792f4c41/ormsgpack-1.12.2-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:458e4568be13d311ef7d8877275e7ccbe06c0e01b39baaac874caaa0f46d826c", size = 482346, upload-time = "2026-01-18T20:55:39.831Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/f5/e1745ddf4fa246c921b5ca253636c4c700ff768d78032f79171289159f6e/ormsgpack-1.12.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8cde5eaa6c6cbc8622db71e4a23de56828e3d876aeb6460ffbcb5b8aff91093b", size = 425178, upload-time = "2026-01-18T20:55:27.106Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/a2/e6532ed7716aed03dede8df2d0d0d4150710c2122647d94b474147ccd891/ormsgpack-1.12.2-cp310-cp310-win_amd64.whl", hash = "sha256:dc7a33be14c347893edbb1ceda89afbf14c467d593a5ee92c11de4f1666b4d4f", size = 117183, upload-time = "2026-01-18T20:55:55.52Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/08/8b68f24b18e69d92238aa8f258218e6dfeacf4381d9d07ab8df303f524a9/ormsgpack-1.12.2-cp311-cp311-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:bd5f4bf04c37888e864f08e740c5a573c4017f6fd6e99fa944c5c935fabf2dd9", size = 378266, upload-time = "2026-01-18T20:55:59.876Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/24/29fc13044ecb7c153523ae0a1972269fcd613650d1fa1a9cec1044c6b666/ormsgpack-1.12.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:34d5b28b3570e9fed9a5a76528fc7230c3c76333bc214798958e58e9b79cc18a", size = 203035, upload-time = "2026-01-18T20:55:30.59Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/c2/00169fb25dd8f9213f5e8a549dfb73e4d592009ebc85fbbcd3e1dcac575b/ormsgpack-1.12.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3708693412c28f3538fb5a65da93787b6bbab3484f6bc6e935bfb77a62400ae5", size = 210539, upload-time = "2026-01-18T20:55:48.569Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/33/543627f323ff3c73091f51d6a20db28a1a33531af30873ea90c5ac95a9b5/ormsgpack-1.12.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:43013a3f3e2e902e1d05e72c0f1aeb5bedbb8e09240b51e26792a3c89267e181", size = 212401, upload-time = "2026-01-18T20:56:10.101Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/5d/f70e2c3da414f46186659d24745483757bcc9adccb481a6eb93e2b729301/ormsgpack-1.12.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7c8b1667a72cbba74f0ae7ecf3105a5e01304620ed14528b2cb4320679d2869b", size = 387082, upload-time = "2026-01-18T20:56:12.047Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/d6/06e8dc920c7903e051f30934d874d4afccc9bb1c09dcaf0bc03a7de4b343/ormsgpack-1.12.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:df6961442140193e517303d0b5d7bc2e20e69a879c2d774316125350c4a76b92", size = 482346, upload-time = "2026-01-18T20:56:05.152Z" },
+    { url = "https://files.pythonhosted.org/packages/66/c4/f337ac0905eed9c393ef990c54565cd33644918e0a8031fe48c098c71dbf/ormsgpack-1.12.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c6a4c34ddef109647c769d69be65fa1de7a6022b02ad45546a69b3216573eb4a", size = 425181, upload-time = "2026-01-18T20:55:37.83Z" },
+    { url = "https://files.pythonhosted.org/packages/78/29/6d5758fabef3babdf4bbbc453738cc7de9cd3334e4c38dd5737e27b85653/ormsgpack-1.12.2-cp311-cp311-win_amd64.whl", hash = "sha256:73670ed0375ecc303858e3613f407628dd1fca18fe6ac57b7b7ce66cc7bb006c", size = 117182, upload-time = "2026-01-18T20:55:31.472Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/57/17a15549233c37e7fd054c48fe9207492e06b026dbd872b826a0b5f833b6/ormsgpack-1.12.2-cp311-cp311-win_arm64.whl", hash = "sha256:c2be829954434e33601ae5da328cccce3266b098927ca7a30246a0baec2ce7bd", size = 111464, upload-time = "2026-01-18T20:55:38.811Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/36/16c4b1921c308a92cef3bf6663226ae283395aa0ff6e154f925c32e91ff5/ormsgpack-1.12.2-cp312-cp312-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:7a29d09b64b9694b588ff2f80e9826bdceb3a2b91523c5beae1fab27d5c940e7", size = 378618, upload-time = "2026-01-18T20:55:50.835Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/68/468de634079615abf66ed13bb5c34ff71da237213f29294363beeeca5306/ormsgpack-1.12.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0b39e629fd2e1c5b2f46f99778450b59454d1f901bc507963168985e79f09c5d", size = 203186, upload-time = "2026-01-18T20:56:11.163Z" },
+    { url = "https://files.pythonhosted.org/packages/73/a9/d756e01961442688b7939bacd87ce13bfad7d26ce24f910f6028178b2cc8/ormsgpack-1.12.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:958dcb270d30a7cb633a45ee62b9444433fa571a752d2ca484efdac07480876e", size = 210738, upload-time = "2026-01-18T20:56:09.181Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/ba/795b1036888542c9113269a3f5690ab53dd2258c6fb17676ac4bd44fcf94/ormsgpack-1.12.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58d379d72b6c5e964851c77cfedfb386e474adee4fd39791c2c5d9efb53505cc", size = 212569, upload-time = "2026-01-18T20:56:06.135Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/aa/bff73c57497b9e0cba8837c7e4bcab584b1a6dbc91a5dd5526784a5030c8/ormsgpack-1.12.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8463a3fc5f09832e67bdb0e2fda6d518dc4281b133166146a67f54c08496442e", size = 387166, upload-time = "2026-01-18T20:55:36.738Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/cf/f8283cba44bcb7b14f97b6274d449db276b3a86589bdb363169b51bc12de/ormsgpack-1.12.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:eddffb77eff0bad4e67547d67a130604e7e2dfbb7b0cde0796045be4090f35c6", size = 482498, upload-time = "2026-01-18T20:55:29.626Z" },
+    { url = "https://files.pythonhosted.org/packages/05/be/71e37b852d723dfcbe952ad04178c030df60d6b78eba26bfd14c9a40575e/ormsgpack-1.12.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fcd55e5f6ba0dbce624942adf9f152062135f991a0126064889f68eb850de0dd", size = 425518, upload-time = "2026-01-18T20:55:49.556Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/0c/9803aa883d18c7ef197213cd2cbf73ba76472a11fe100fb7dab2884edf48/ormsgpack-1.12.2-cp312-cp312-win_amd64.whl", hash = "sha256:d024b40828f1dde5654faebd0d824f9cc29ad46891f626272dd5bfd7af2333a4", size = 117462, upload-time = "2026-01-18T20:55:47.726Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/9e/029e898298b2cc662f10d7a15652a53e3b525b1e7f07e21fef8536a09bb8/ormsgpack-1.12.2-cp312-cp312-win_arm64.whl", hash = "sha256:da538c542bac7d1c8f3f2a937863dba36f013108ce63e55745941dda4b75dbb6", size = 111559, upload-time = "2026-01-18T20:55:54.273Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/29/bb0eba3288c0449efbb013e9c6f58aea79cf5cb9ee1921f8865f04c1a9d7/ormsgpack-1.12.2-cp313-cp313-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:5ea60cb5f210b1cfbad8c002948d73447508e629ec375acb82910e3efa8ff355", size = 378661, upload-time = "2026-01-18T20:55:57.765Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/31/5efa31346affdac489acade2926989e019e8ca98129658a183e3add7af5e/ormsgpack-1.12.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f3601f19afdbea273ed70b06495e5794606a8b690a568d6c996a90d7255e51c1", size = 203194, upload-time = "2026-01-18T20:56:08.252Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/56/d0087278beef833187e0167f8527235ebe6f6ffc2a143e9de12a98b1ce87/ormsgpack-1.12.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:29a9f17a3dac6054c0dce7925e0f4995c727f7c41859adf9b5572180f640d172", size = 210778, upload-time = "2026-01-18T20:55:17.694Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/a2/072343e1413d9443e5a252a8eb591c2d5b1bffbe5e7bfc78c069361b92eb/ormsgpack-1.12.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39c1bd2092880e413902910388be8715f70b9f15f20779d44e673033a6146f2d", size = 212592, upload-time = "2026-01-18T20:55:32.747Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/8b/a0da3b98a91d41187a63b02dda14267eefc2a74fcb43cc2701066cf1510e/ormsgpack-1.12.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:50b7249244382209877deedeee838aef1542f3d0fc28b8fe71ca9d7e1896a0d7", size = 387164, upload-time = "2026-01-18T20:55:40.853Z" },
+    { url = "https://files.pythonhosted.org/packages/19/bb/6d226bc4cf9fc20d8eb1d976d027a3f7c3491e8f08289a2e76abe96a65f3/ormsgpack-1.12.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:5af04800d844451cf102a59c74a841324868d3f1625c296a06cc655c542a6685", size = 482516, upload-time = "2026-01-18T20:55:42.033Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/f1/bb2c7223398543dedb3dbf8bb93aaa737b387de61c5feaad6f908841b782/ormsgpack-1.12.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:cec70477d4371cd524534cd16472d8b9cc187e0e3043a8790545a9a9b296c258", size = 425539, upload-time = "2026-01-18T20:55:24.727Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/e8/0fb45f57a2ada1fed374f7494c8cd55e2f88ccd0ab0a669aa3468716bf5f/ormsgpack-1.12.2-cp313-cp313-win_amd64.whl", hash = "sha256:21f4276caca5c03a818041d637e4019bc84f9d6ca8baa5ea03e5cc8bf56140e9", size = 117459, upload-time = "2026-01-18T20:55:56.876Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/d4/0cfeea1e960d550a131001a7f38a5132c7ae3ebde4c82af1f364ccc5d904/ormsgpack-1.12.2-cp313-cp313-win_arm64.whl", hash = "sha256:baca4b6773d20a82e36d6fd25f341064244f9f86a13dead95dd7d7f996f51709", size = 111577, upload-time = "2026-01-18T20:55:43.605Z" },
+    { url = "https://files.pythonhosted.org/packages/94/16/24d18851334be09c25e87f74307c84950f18c324a4d3c0b41dabdbf19c29/ormsgpack-1.12.2-cp314-cp314-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:bc68dd5915f4acf66ff2010ee47c8906dc1cf07399b16f4089f8c71733f6e36c", size = 378717, upload-time = "2026-01-18T20:55:26.164Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/a2/88b9b56f83adae8032ac6a6fa7f080c65b3baf9b6b64fd3d37bd202991d4/ormsgpack-1.12.2-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:46d084427b4132553940070ad95107266656cb646ea9da4975f85cb1a6676553", size = 203183, upload-time = "2026-01-18T20:55:18.815Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/80/43e4555963bf602e5bdc79cbc8debd8b6d5456c00d2504df9775e74b450b/ormsgpack-1.12.2-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c010da16235806cf1d7bc4c96bf286bfa91c686853395a299b3ddb49499a3e13", size = 210814, upload-time = "2026-01-18T20:55:33.973Z" },
+    { url = "https://files.pythonhosted.org/packages/78/e1/7cfbf28de8bca6efe7e525b329c31277d1b64ce08dcba723971c241a9d60/ormsgpack-1.12.2-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18867233df592c997154ff942a6503df274b5ac1765215bceba7a231bea2745d", size = 212634, upload-time = "2026-01-18T20:55:28.634Z" },
+    { url = "https://files.pythonhosted.org/packages/95/f8/30ae5716e88d792a4e879debee195653c26ddd3964c968594ddef0a3cc7e/ormsgpack-1.12.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b009049086ddc6b8f80c76b3955df1aa22a5fbd7673c525cd63bf91f23122ede", size = 387139, upload-time = "2026-01-18T20:56:02.013Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/81/aee5b18a3e3a0e52f718b37ab4b8af6fae0d9d6a65103036a90c2a8ffb5d/ormsgpack-1.12.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:1dcc17d92b6390d4f18f937cf0b99054824a7815818012ddca925d6e01c2e49e", size = 482578, upload-time = "2026-01-18T20:55:35.117Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/17/71c9ba472d5d45f7546317f467a5fc941929cd68fb32796ca3d13dcbaec2/ormsgpack-1.12.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f04b5e896d510b07c0ad733d7fce2d44b260c5e6c402d272128f8941984e4285", size = 425539, upload-time = "2026-01-18T20:56:04.009Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/a6/ac99cd7fe77e822fed5250ff4b86fa66dd4238937dd178d2299f10b69816/ormsgpack-1.12.2-cp314-cp314-win_amd64.whl", hash = "sha256:ae3aba7eed4ca7cb79fd3436eddd29140f17ea254b91604aa1eb19bfcedb990f", size = 117493, upload-time = "2026-01-18T20:56:07.343Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/67/339872846a1ae4592535385a1c1f93614138566d7af094200c9c3b45d1e5/ormsgpack-1.12.2-cp314-cp314-win_arm64.whl", hash = "sha256:118576ea6006893aea811b17429bfc561b4778fad393f5f538c84af70b01260c", size = 111579, upload-time = "2026-01-18T20:55:21.161Z" },
+    { url = "https://files.pythonhosted.org/packages/49/c2/6feb972dc87285ad381749d3882d8aecbde9f6ecf908dd717d33d66df095/ormsgpack-1.12.2-cp314-cp314t-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:7121b3d355d3858781dc40dafe25a32ff8a8242b9d80c692fd548a4b1f7fd3c8", size = 378721, upload-time = "2026-01-18T20:55:52.12Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/9a/900a6b9b413e0f8a471cf07830f9cf65939af039a362204b36bd5b581d8b/ormsgpack-1.12.2-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4ee766d2e78251b7a63daf1cddfac36a73562d3ddef68cacfb41b2af64698033", size = 203170, upload-time = "2026-01-18T20:55:44.469Z" },
+    { url = "https://files.pythonhosted.org/packages/87/4c/27a95466354606b256f24fad464d7c97ab62bce6cc529dd4673e1179b8fb/ormsgpack-1.12.2-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:292410a7d23de9b40444636b9b8f1e4e4b814af7f1ef476e44887e52a123f09d", size = 212816, upload-time = "2026-01-18T20:55:23.501Z" },
+    { url = "https://files.pythonhosted.org/packages/73/cd/29cee6007bddf7a834e6cd6f536754c0535fcb939d384f0f37a38b1cddb8/ormsgpack-1.12.2-cp314-cp314t-win_amd64.whl", hash = "sha256:837dd316584485b72ef451d08dd3e96c4a11d12e4963aedb40e08f89685d8ec2", size = 117232, upload-time = "2026-01-18T20:55:45.448Z" },
 ]
 
 [[package]]
@@ -1197,14 +1198,14 @@ wheels = [
 
 [[package]]
 name = "redis"
-version = "7.1.0"
+version = "7.1.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "async-timeout", marker = "python_full_version < '3.11.3'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/43/c8/983d5c6579a411d8a99bc5823cc5712768859b5ce2c8afe1a65b37832c81/redis-7.1.0.tar.gz", hash = "sha256:b1cc3cfa5a2cb9c2ab3ba700864fb0ad75617b41f01352ce5779dabf6d5f9c3c", size = 4796669, upload-time = "2025-11-19T15:54:39.961Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f7/80/2971931d27651affa88a44c0ad7b8c4a19dc29c998abb20b23868d319b59/redis-7.1.1.tar.gz", hash = "sha256:a2814b2bda15b39dad11391cc48edac4697214a8a5a4bd10abe936ab4892eb43", size = 4800064, upload-time = "2026-02-09T18:39:40.292Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/89/f0/8956f8a86b20d7bb9d6ac0187cf4cd54d8065bc9a1a09eb8011d4d326596/redis-7.1.0-py3-none-any.whl", hash = "sha256:23c52b208f92b56103e17c5d06bdc1a6c2c0b3106583985a76a18f83b265de2b", size = 354159, upload-time = "2025-11-19T15:54:38.064Z" },
+    { url = "https://files.pythonhosted.org/packages/29/55/1de1d812ba1481fa4b37fb03b4eec0fcb71b6a0d44c04ea3482eb017600f/redis-7.1.1-py3-none-any.whl", hash = "sha256:f77817f16071c2950492c67d40b771fa493eb3fccc630a424a10976dbb794b7a", size = 356057, upload-time = "2026-02-09T18:39:38.602Z" },
 ]
 
 [[package]]
@@ -1236,28 +1237,27 @@ wheels = [
 
 [[package]]
 name = "ruff"
-version = "0.14.13"
+version = "0.15.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/50/0a/1914efb7903174b381ee2ffeebb4253e729de57f114e63595114c8ca451f/ruff-0.14.13.tar.gz", hash = "sha256:83cd6c0763190784b99650a20fec7633c59f6ebe41c5cc9d45ee42749563ad47", size = 6059504, upload-time = "2026-01-15T20:15:16.918Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/dc/4e6ac71b511b141cf626357a3946679abeba4cf67bc7cc5a17920f31e10d/ruff-0.15.1.tar.gz", hash = "sha256:c590fe13fb57c97141ae975c03a1aedb3d3156030cabd740d6ff0b0d601e203f", size = 4540855, upload-time = "2026-02-12T23:09:09.998Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c3/ae/0deefbc65ca74b0ab1fd3917f94dc3b398233346a74b8bbb0a916a1a6bf6/ruff-0.14.13-py3-none-linux_armv6l.whl", hash = "sha256:76f62c62cd37c276cb03a275b198c7c15bd1d60c989f944db08a8c1c2dbec18b", size = 13062418, upload-time = "2026-01-15T20:14:50.779Z" },
-    { url = "https://files.pythonhosted.org/packages/47/df/5916604faa530a97a3c154c62a81cb6b735c0cb05d1e26d5ad0f0c8ac48a/ruff-0.14.13-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:914a8023ece0528d5cc33f5a684f5f38199bbb566a04815c2c211d8f40b5d0ed", size = 13442344, upload-time = "2026-01-15T20:15:07.94Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/f3/e0e694dd69163c3a1671e102aa574a50357536f18a33375050334d5cd517/ruff-0.14.13-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d24899478c35ebfa730597a4a775d430ad0d5631b8647a3ab368c29b7e7bd063", size = 12354720, upload-time = "2026-01-15T20:15:09.854Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/e8/67f5fcbbaee25e8fc3b56cc33e9892eca7ffe09f773c8e5907757a7e3bdb/ruff-0.14.13-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9aaf3870f14d925bbaf18b8a2347ee0ae7d95a2e490e4d4aea6813ed15ebc80e", size = 12774493, upload-time = "2026-01-15T20:15:20.908Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/ce/d2e9cb510870b52a9565d885c0d7668cc050e30fa2c8ac3fb1fda15c083d/ruff-0.14.13-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac5b7f63dd3b27cc811850f5ffd8fff845b00ad70e60b043aabf8d6ecc304e09", size = 12815174, upload-time = "2026-01-15T20:15:05.74Z" },
-    { url = "https://files.pythonhosted.org/packages/88/00/c38e5da58beebcf4fa32d0ddd993b63dfacefd02ab7922614231330845bf/ruff-0.14.13-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:78d2b1097750d90ba82ce4ba676e85230a0ed694178ca5e61aa9b459970b3eb9", size = 13680909, upload-time = "2026-01-15T20:15:14.537Z" },
-    { url = "https://files.pythonhosted.org/packages/61/61/cd37c9dd5bd0a3099ba79b2a5899ad417d8f3b04038810b0501a80814fd7/ruff-0.14.13-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:7d0bf87705acbbcb8d4c24b2d77fbb73d40210a95c3903b443cd9e30824a5032", size = 15144215, upload-time = "2026-01-15T20:15:22.886Z" },
-    { url = "https://files.pythonhosted.org/packages/56/8a/85502d7edbf98c2df7b8876f316c0157359165e16cdf98507c65c8d07d3d/ruff-0.14.13-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a3eb5da8e2c9e9f13431032fdcbe7681de9ceda5835efee3269417c13f1fed5c", size = 14706067, upload-time = "2026-01-15T20:14:48.271Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/2f/de0df127feb2ee8c1e54354dc1179b4a23798f0866019528c938ba439aca/ruff-0.14.13-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:642442b42957093811cd8d2140dfadd19c7417030a7a68cf8d51fcdd5f217427", size = 14133916, upload-time = "2026-01-15T20:14:57.357Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/77/9b99686bb9fe07a757c82f6f95e555c7a47801a9305576a9c67e0a31d280/ruff-0.14.13-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4acdf009f32b46f6e8864af19cbf6841eaaed8638e65c8dac845aea0d703c841", size = 13859207, upload-time = "2026-01-15T20:14:55.111Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/46/2bdcb34a87a179a4d23022d818c1c236cb40e477faf0d7c9afb6813e5876/ruff-0.14.13-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:591a7f68860ea4e003917d19b5c4f5ac39ff558f162dc753a2c5de897fd5502c", size = 14043686, upload-time = "2026-01-15T20:14:52.841Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/a9/5c6a4f56a0512c691cf143371bcf60505ed0f0860f24a85da8bd123b2bf1/ruff-0.14.13-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:774c77e841cc6e046fc3e91623ce0903d1cd07e3a36b1a9fe79b81dab3de506b", size = 12663837, upload-time = "2026-01-15T20:15:18.921Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/bb/b920016ece7651fa7fcd335d9d199306665486694d4361547ccb19394c44/ruff-0.14.13-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:61f4e40077a1248436772bb6512db5fc4457fe4c49e7a94ea7c5088655dd21ae", size = 12805867, upload-time = "2026-01-15T20:14:59.272Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/b3/0bd909851e5696cd21e32a8fc25727e5f58f1934b3596975503e6e85415c/ruff-0.14.13-py3-none-musllinux_1_2_i686.whl", hash = "sha256:6d02f1428357fae9e98ac7aa94b7e966fd24151088510d32cf6f902d6c09235e", size = 13208528, upload-time = "2026-01-15T20:15:03.732Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/3b/e2d94cb613f6bbd5155a75cbe072813756363eba46a3f2177a1fcd0cd670/ruff-0.14.13-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e399341472ce15237be0c0ae5fbceca4b04cd9bebab1a2b2c979e015455d8f0c", size = 13929242, upload-time = "2026-01-15T20:15:11.918Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/c5/abd840d4132fd51a12f594934af5eba1d5d27298a6f5b5d6c3be45301caf/ruff-0.14.13-py3-none-win32.whl", hash = "sha256:ef720f529aec113968b45dfdb838ac8934e519711da53a0456038a0efecbd680", size = 12919024, upload-time = "2026-01-15T20:14:43.647Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/55/6384b0b8ce731b6e2ade2b5449bf07c0e4c31e8a2e68ea65b3bafadcecc5/ruff-0.14.13-py3-none-win_amd64.whl", hash = "sha256:6070bd026e409734b9257e03e3ef18c6e1a216f0435c6751d7a8ec69cb59abef", size = 14097887, upload-time = "2026-01-15T20:15:01.48Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/e1/7348090988095e4e39560cfc2f7555b1b2a7357deba19167b600fdf5215d/ruff-0.14.13-py3-none-win_arm64.whl", hash = "sha256:7ab819e14f1ad9fe39f246cfcc435880ef7a9390d81a2b6ac7e01039083dd247", size = 13080224, upload-time = "2026-01-15T20:14:45.853Z" },
+    { url = "https://files.pythonhosted.org/packages/23/bf/e6e4324238c17f9d9120a9d60aa99a7daaa21204c07fcd84e2ef03bb5fd1/ruff-0.15.1-py3-none-linux_armv6l.whl", hash = "sha256:b101ed7cf4615bda6ffe65bdb59f964e9f4a0d3f85cbf0e54f0ab76d7b90228a", size = 10367819, upload-time = "2026-02-12T23:09:03.598Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/ea/c8f89d32e7912269d38c58f3649e453ac32c528f93bb7f4219258be2e7ed/ruff-0.15.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:939c995e9277e63ea632cc8d3fae17aa758526f49a9a850d2e7e758bfef46602", size = 10798618, upload-time = "2026-02-12T23:09:22.928Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/0f/1d0d88bc862624247d82c20c10d4c0f6bb2f346559d8af281674cf327f15/ruff-0.15.1-py3-none-macosx_11_0_arm64.whl", hash = "sha256:1d83466455fdefe60b8d9c8df81d3c1bbb2115cede53549d3b522ce2bc703899", size = 10148518, upload-time = "2026-02-12T23:08:58.339Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/c8/291c49cefaa4a9248e986256df2ade7add79388fe179e0691be06fae6f37/ruff-0.15.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9457e3c3291024866222b96108ab2d8265b477e5b1534c7ddb1810904858d16", size = 10518811, upload-time = "2026-02-12T23:09:31.865Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/1a/f5707440e5ae43ffa5365cac8bbb91e9665f4a883f560893829cf16a606b/ruff-0.15.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:92c92b003e9d4f7fbd33b1867bb15a1b785b1735069108dfc23821ba045b29bc", size = 10196169, upload-time = "2026-02-12T23:09:17.306Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/ff/26ddc8c4da04c8fd3ee65a89c9fb99eaa5c30394269d424461467be2271f/ruff-0.15.1-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fe5c41ab43e3a06778844c586251eb5a510f67125427625f9eb2b9526535779", size = 10990491, upload-time = "2026-02-12T23:09:25.503Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/00/50920cb385b89413f7cdb4bb9bc8fc59c1b0f30028d8bccc294189a54955/ruff-0.15.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66a6dd6df4d80dc382c6484f8ce1bcceb55c32e9f27a8b94c32f6c7331bf14fb", size = 11843280, upload-time = "2026-02-12T23:09:19.88Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/6d/2f5cad8380caf5632a15460c323ae326f1e1a2b5b90a6ee7519017a017ca/ruff-0.15.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6a4a42cbb8af0bda9bcd7606b064d7c0bc311a88d141d02f78920be6acb5aa83", size = 11274336, upload-time = "2026-02-12T23:09:14.907Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/1d/5f56cae1d6c40b8a318513599b35ea4b075d7dc1cd1d04449578c29d1d75/ruff-0.15.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4ab064052c31dddada35079901592dfba2e05f5b1e43af3954aafcbc1096a5b2", size = 11137288, upload-time = "2026-02-12T23:09:07.475Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/20/6f8d7d8f768c93b0382b33b9306b3b999918816da46537d5a61635514635/ruff-0.15.1-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:5631c940fe9fe91f817a4c2ea4e81f47bee3ca4aa646134a24374f3c19ad9454", size = 11070681, upload-time = "2026-02-12T23:08:55.43Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/67/d640ac76069f64cdea59dba02af2e00b1fa30e2103c7f8d049c0cff4cafd/ruff-0.15.1-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:68138a4ba184b4691ccdc39f7795c66b3c68160c586519e7e8444cf5a53e1b4c", size = 10486401, upload-time = "2026-02-12T23:09:27.927Z" },
+    { url = "https://files.pythonhosted.org/packages/65/3d/e1429f64a3ff89297497916b88c32a5cc88eeca7e9c787072d0e7f1d3e1e/ruff-0.15.1-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:518f9af03bfc33c03bdb4cb63fabc935341bb7f54af500f92ac309ecfbba6330", size = 10197452, upload-time = "2026-02-12T23:09:12.147Z" },
+    { url = "https://files.pythonhosted.org/packages/78/83/e2c3bade17dad63bf1e1c2ffaf11490603b760be149e1419b07049b36ef2/ruff-0.15.1-py3-none-musllinux_1_2_i686.whl", hash = "sha256:da79f4d6a826caaea95de0237a67e33b81e6ec2e25fc7e1993a4015dffca7c61", size = 10693900, upload-time = "2026-02-12T23:09:34.418Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/27/fdc0e11a813e6338e0706e8b39bb7a1d61ea5b36873b351acee7e524a72a/ruff-0.15.1-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:3dd86dccb83cd7d4dcfac303ffc277e6048600dfc22e38158afa208e8bf94a1f", size = 11227302, upload-time = "2026-02-12T23:09:36.536Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/58/ac864a75067dcbd3b95be5ab4eb2b601d7fbc3d3d736a27e391a4f92a5c1/ruff-0.15.1-py3-none-win32.whl", hash = "sha256:660975d9cb49b5d5278b12b03bb9951d554543a90b74ed5d366b20e2c57c2098", size = 10462555, upload-time = "2026-02-12T23:09:29.899Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/5e/d4ccc8a27ecdb78116feac4935dfc39d1304536f4296168f91ed3ec00cd2/ruff-0.15.1-py3-none-win_amd64.whl", hash = "sha256:c820fef9dd5d4172a6570e5721704a96c6679b80cf7be41659ed439653f62336", size = 11599956, upload-time = "2026-02-12T23:09:01.157Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/07/5bda6a85b220c64c65686bc85bd0bbb23b29c62b3a9f9433fa55f17cda93/ruff-0.15.1-py3-none-win_arm64.whl", hash = "sha256:5ff7d5f0f88567850f45081fac8f4ec212be8d0b963e385c3f7d0d2eb4899416", size = 10874604, upload-time = "2026-02-12T23:09:05.515Z" },
 ]
 
 [[package]]

libs/cli/.gitignore

@@ -1 +1,10 @@
 .langgraph_api/
+npm/
+
+# Rust build artifacts
+/target/
+/dist/
+
+# npm platform binaries (added at build time, not checked in)
+npm/*/bin/langgraph
+npm/*/bin/langgraph.exe

libs/cli/Cargo.toml

@@ -0,0 +1,37 @@
+[package]
+name = "langgraph-cli"
+version = "0.2.10"
+edition = "2021"
+description = "Native CLI for LangGraph"
+license = "MIT"
+
+[[bin]]
+name = "langgraph"
+path = "src/main.rs"
+
+[dependencies]
+clap = { version = "4", features = ["derive"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = { version = "1" }
+reqwest = { version = "0.12", features = ["rustls-tls", "blocking"], default-features = false }
+zip = "2"
+indexmap = { version = "2", features = ["serde"] }
+open = "5"
+indicatif = "0.17"
+console = "0.15"
+dotenvy = "0.15"
+tempfile = "3"
+thiserror = "2"
+dialoguer = "0.11"
+regex = "1"
+which = "7"
+
+[dev-dependencies]
+assert_cmd = "2"
+predicates = "3"
+
+[profile.release]
+opt-level = 3
+lto = "thin"
+codegen-units = 1
+strip = "symbols"

libs/cli/Makefile

@@ -1,7 +1,27 @@
-.PHONY: test lint format test-integration update-schema bump-version
+.PHONY: test lint format test-integration update-schema build build-release clean cargo-test cargo-lint
 
 ######################
-# TESTING AND COVERAGE
+# RUST BUILD
+######################
+
+build:
+	cargo build
+
+build-release:
+	cargo build --release
+
+cargo-test:
+	cargo test
+
+cargo-lint:
+	cargo fmt --check
+	cargo clippy -- -D warnings
+
+cargo-fmt:
+	cargo fmt
+
+######################
+# PYTHON TESTING AND COVERAGE
 ######################
 
 TEST?= "tests/unit_tests"
@@ -11,7 +31,7 @@ test-integration:
 	uv run pytest tests/integration_tests
 
 ######################
-# LINTING AND FORMATTING
+# PYTHON LINTING AND FORMATTING
 ######################
 
 # Define a variable for Python and notebook files.
@@ -33,8 +53,35 @@ format format_diff:
 	uv run ruff format $(PYTHON_FILES)
 	uv run ruff check --select I --fix $(PYTHON_FILES)
 
+######################
+# PACKAGING
+######################
+
+# Build maturin wheel for current platform (development)
+wheel-dev:
+	maturin build --release
+
+# Build maturin wheel for specific target
+# Usage: make wheel TARGET=x86_64-unknown-linux-gnu
+TARGET?=
+wheel:
+	maturin build --release $(if $(TARGET),--target $(TARGET),)
+
+# Build sdist
+sdist:
+	maturin sdist
+
+######################
+# SCHEMA
+######################
+
 update-schema:
 	uv run python generate_schema.py
 
-bump-version:
-	uv run hatch version patch
+######################
+# CLEANUP
+######################
+
+clean:
+	cargo clean
+	rm -rf dist/ target/wheels/

libs/cli/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    // Cargo already sets CARGO_PKG_VERSION, nothing to do
+}

libs/cli/examples/graph_prerelease_reqs/deps/additional_deps/pyproject.toml

@@ -5,5 +5,5 @@ description = "Test for prerelease stuff"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-  "langgraph==1.0.2"
+  "langgraph==1.0.8"
 ]

libs/cli/examples/graph_prerelease_reqs/pyproject.toml

@@ -7,7 +7,7 @@ requires-python = ">=3.10"
 dependencies = [
   "langchain-openai==1.0.0a2",
   "langchain-anthropic==1.0.0a5",
-  "langgraph==1.0.2"
+  "langgraph==1.0.8"
 ]
 
 [tool.uv]

libs/cli/js-examples/package.json

@@ -21,25 +21,25 @@
     "test:all": "yarn test && yarn test:int && yarn lint:langgraph"
   },
   "dependencies": {
-    "@langchain/core": "^0.3.2",
-    "@langchain/langgraph": "^0.2.5"
+    "@langchain/core": "^1.1.24",
+    "@langchain/langgraph": "^1.1.4"
   },
   "devDependencies": {
-    "@eslint/eslintrc": "^3.1.0",
-    "@eslint/js": "^9.9.1",
-    "@tsconfig/recommended": "^1.0.7",
-    "@types/jest": "^29.5.0",
-    "@typescript-eslint/eslint-plugin": "^5.59.8",
-    "@typescript-eslint/parser": "^5.59.8",
-    "dotenv": "^16.4.5",
-    "eslint": "^8.41.0",
-    "eslint-config-prettier": "^8.8.0",
-    "eslint-plugin-import": "^2.27.5",
+    "@eslint/eslintrc": "^3.3.3",
+    "@eslint/js": "^10.0.1",
+    "@tsconfig/recommended": "^1.0.13",
+    "@types/jest": "^30.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.55.0",
+    "@typescript-eslint/parser": "^8.55.0",
+    "dotenv": "^17.3.1",
+    "eslint": "^10.0.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-no-instanceof": "^1.0.1",
-    "eslint-plugin-prettier": "^4.2.1",
-    "jest": "^29.7.0",
-    "prettier": "^3.3.3",
-    "ts-jest": "^29.1.0",
-    "typescript": "^5.3.3"
+    "eslint-plugin-prettier": "^5.5.5",
+    "jest": "^30.2.0",
+    "prettier": "^3.8.1",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.9.3"
   }
 }

libs/cli/js-monorepo-example/apps/agent/package.json

@@ -9,10 +9,10 @@
   },
   "dependencies": {
     "@js-monorepo-example/shared": "*",
-    "@langchain/core": "^0.3.2",
-    "@langchain/langgraph": "^0.2.5"
+    "@langchain/core": "^1.1.24",
+    "@langchain/langgraph": "^1.1.4"
   },
   "devDependencies": {
-    "typescript": "^5.3.3"
+    "typescript": "^5.9.3"
   }
 }

libs/cli/js-monorepo-example/libs/shared/package.json

@@ -9,6 +9,6 @@
     "clean": "rm -rf dist"
   },
   "devDependencies": {
-    "typescript": "^5.3.3"
+    "typescript": "^5.9.3"
   }
 }

libs/cli/js-monorepo-example/package.json

@@ -17,18 +17,18 @@
     "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",
+    "turbo": "^2.8.9",
+    "typescript": "^5.9.3",
+    "@tsconfig/recommended": "^1.0.13",
+    "@eslint/eslintrc": "^3.3.3",
+    "@eslint/js": "^10.0.1",
+    "eslint": "^10.0.0",
+    "eslint-config-prettier": "^10.1.8",
     "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"
+    "eslint-plugin-prettier": "^5.5.5",
+    "@typescript-eslint/eslint-plugin": "^8.56.0",
+    "@typescript-eslint/parser": "^8.56.0",
+    "prettier": "^3.8.1"
   }
 }

libs/cli/langgraph_cli/__init__.py

@@ -1 +1 @@
-__version__ = "0.4.12"
+__version__ = "0.4.13"

libs/cli/langgraph_cli/config.py

@@ -196,6 +196,11 @@ def validate_config(config: Config) -> Config:
                 f"Python version {pyversion} is not supported. "
                 f"Minimum required version is {MIN_PYTHON_VERSION}."
             )
+        if "bullseye" in pyversion:
+            raise click.UsageError(
+                "Bullseye images were deprecated in version 0.4.13. "
+                "Please use 'bookworm' or 'debian' instead."
+            )
 
         if not config["dependencies"]:
             raise click.UsageError(
@@ -210,10 +215,15 @@ def validate_config(config: Config) -> Config:
 
     # Validate image_distro config
     if image_distro := config.get("image_distro"):
+        if image_distro == "bullseye":
+            raise click.UsageError(
+                "Bullseye images were deprecated in version 0.4.13. "
+                "Please use 'bookworm' or 'debian' instead."
+            )
         if image_distro not in Distros.__args__:
             raise click.UsageError(
                 f"Invalid image_distro: '{image_distro}'. "
-                "Must be one of 'debian', 'bullseye', or 'bookworm'."
+                "Must be one of 'debian', 'wolfi', or 'bookworm'."
             )
 
     if pip_installer := config.get("pip_installer"):

libs/cli/langgraph_cli/schemas.py

@@ -1,6 +1,6 @@
 from typing import Any, Literal, TypedDict
 
-Distros = Literal["debian", "wolfi", "bullseye", "bookworm"]
+Distros = Literal["debian", "wolfi", "bookworm"]
 MiddlewareOrders = Literal["auth_first", "middleware_first"]
 
 
@@ -107,17 +107,19 @@ class StoreConfig(TypedDict, total=False):
 class ThreadTTLConfig(TypedDict, total=False):
     """Configure a default TTL for checkpointed data within threads."""
 
-    strategy: Literal["delete"]
-    """Strategy to use for deleting checkpointed data.
-    
-    Choices:
-      - "delete": Delete all checkpoints for a thread after TTL expires.
+    strategy: Literal["delete", "keep_latest"]
+    """Action taken when a thread exceeds its TTL.
+
+    - "delete": Remove the thread and all its data entirely.
+    - "keep_latest": Prune old checkpoints but keep the thread and its latest state.
     """
     default_ttl: float | None
     """Default TTL (time-to-live) in minutes for checkpointed data."""
     sweep_interval_minutes: int | None
     """Interval in minutes between sweep iterations.
     If omitted, a default interval will be used (typically ~ 5 minutes)."""
+    sweep_limit: int | None
+    """Maximum number of threads to process per sweep iteration. Defaults to 1000."""
 
 
 class SerdeConfig(TypedDict, total=False):
@@ -173,14 +175,12 @@ class CheckpointerConfig(TypedDict, total=False):
     """
     serde: SerdeConfig | None
     """Optional. Defines the serde configuration.
-    
+
     If provided, the checkpointer will apply serde settings according to the configuration.
     If omitted, no serde behavior is configured.
 
     This configuration requires server version 0.5 or later to take effect.
     """
-    sweep_limit: int | None
-    """Maximum number of threads to process per sweep iteration. Defaults to 1000."""
 
 
 class SecurityConfig(TypedDict, total=False):
@@ -559,7 +559,7 @@ class Config(TypedDict, total=False):
     image_distro: Distros | None
     """Optional. Linux distribution for the base image.
     
-    Must be one of 'wolfi', 'debian', 'bullseye', or 'bookworm'.
+    Must be one of 'wolfi', 'debian', or 'bookworm'.
     If omitted, defaults to 'debian' ('latest').
     """
 

libs/cli/pyproject.toml

@@ -1,6 +1,6 @@
 [build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
+requires = ["maturin>=1.0,<2.0"]
+build-backend = "maturin"
 
 [project]
 name = "langgraph-cli"
@@ -11,12 +11,8 @@ requires-python = ">=3.10"
 readme = "README.md"
 license = "MIT"
 license-files = ['LICENSE']
-dependencies = [
-    "click>=8.1.7",
-    "langgraph-sdk>=0.1.0 ; python_version >= '3.11'",
-]
-[tool.hatch.version]
-path = "langgraph_cli/__init__.py"
+dependencies = []
+
 [project.optional-dependencies]
 inmem = [
     "langgraph-api>=0.5.35,<0.8.0 ; python_version >= '3.11'",
@@ -30,8 +26,10 @@ Twitter = "https://x.com/LangChain"
 Slack = "https://www.langchain.com/join-community"
 Reddit = "https://www.reddit.com/r/LangChain/"
 
-[project.scripts]
-langgraph = "langgraph_cli.cli:cli"
+[tool.maturin]
+bindings = "bin"
+manifest-path = "Cargo.toml"
+strip = true
 
 [dependency-groups]
 test = [
@@ -49,15 +47,11 @@ lint = [
 dev = [
     {include-group = "test"},
     {include-group = "lint"},
-    "hatch>=1.16.2",
 ]
 
 [tool.uv]
 default-groups = ['dev']
 
-[tool.hatch.build.targets.wheel]
-include = ["langgraph_cli"]
-
 [tool.pytest.ini_options]
 addopts = "--strict-markers --strict-config --durations=5 -vv"
 asyncio_mode = "auto"
@@ -69,7 +63,6 @@ lint.select = [
   "UP", # pyupgrade
   "B",  # flake8-bugbear
   "I",  # isort
-  "UP", # pyupgrade
 ]
 lint.ignore = ["E501", "B008"]
 target-version = "py310"

libs/cli/schemas/schema.json

@@ -147,7 +147,6 @@
                 {
                   "enum": [
                     "bookworm",
-                    "bullseye",
                     "debian",
                     "wolfi"
                   ]
@@ -156,7 +155,7 @@
                   "type": "null"
                 }
               ],
-              "description": "Optional. Linux distribution for the base image.\n\nMust be one of 'wolfi', 'debian', 'bullseye', or 'bookworm'.\nIf omitted, defaults to 'debian' ('latest').\n"
+              "description": "Optional. Linux distribution for the base image.\n\nMust be one of 'wolfi', 'debian', or 'bookworm'.\nIf omitted, defaults to 'debian' ('latest').\n"
             },
             "keep_pkg_tools": {
               "anyOf": [
@@ -370,7 +369,7 @@
                   "type": "null"
                 }
               ],
-              "description": "Optional. Linux distribution for the base image.\n\nMust be one of 'wolfi', 'debian', 'bullseye', or 'bookworm'.\nIf omitted, defaults to 'debian' ('latest').\n"
+              "description": "Optional. Linux distribution for the base image.\n\nMust be one of 'wolfi', 'debian', or 'bookworm'.\nIf omitted, defaults to 'debian' ('latest').\n"
             },
             "keep_pkg_tools": {
               "anyOf": [
@@ -554,17 +553,6 @@
           ],
           "description": "Optional. Defines the serde configuration.\n\nIf provided, the checkpointer will apply serde settings according to the configuration.\nIf omitted, no serde behavior is configured.\n\nThis configuration requires server version 0.5 or later to take effect.\n"
         },
-        "sweep_limit": {
-          "anyOf": [
-            {
-              "type": "integer"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "description": "Maximum number of threads to process per sweep iteration. Defaults to 1000."
-        },
         "ttl": {
           "anyOf": [
             {
@@ -629,9 +617,10 @@
         },
         "strategy": {
           "enum": [
-            "delete"
+            "delete",
+            "keep_latest"
           ],
-          "description": "Strategy to use for deleting checkpointed data.\n"
+          "description": "Action taken when a thread exceeds its TTL.\n\n"
         },
         "sweep_interval_minutes": {
           "anyOf": [
@@ -643,6 +632,17 @@
             }
           ],
           "description": "Interval in minutes between sweep iterations.\nIf omitted, a default interval will be used (typically ~ 5 minutes)."
+        },
+        "sweep_limit": {
+          "anyOf": [
+            {
+              "type": "integer"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "description": "Maximum number of threads to process per sweep iteration. Defaults to 1000."
         }
       },
       "required": []

libs/cli/schemas/schema.v0.json

@@ -147,7 +147,6 @@
                 {
                   "enum": [
                     "bookworm",
-                    "bullseye",
                     "debian",
                     "wolfi"
                   ]
@@ -156,7 +155,7 @@
                   "type": "null"
                 }
               ],
-              "description": "Optional. Linux distribution for the base image.\n\nMust be one of 'wolfi', 'debian', 'bullseye', or 'bookworm'.\nIf omitted, defaults to 'debian' ('latest').\n"
+              "description": "Optional. Linux distribution for the base image.\n\nMust be one of 'wolfi', 'debian', or 'bookworm'.\nIf omitted, defaults to 'debian' ('latest').\n"
             },
             "keep_pkg_tools": {
               "anyOf": [
@@ -370,7 +369,7 @@
                   "type": "null"
                 }
               ],
-              "description": "Optional. Linux distribution for the base image.\n\nMust be one of 'wolfi', 'debian', 'bullseye', or 'bookworm'.\nIf omitted, defaults to 'debian' ('latest').\n"
+              "description": "Optional. Linux distribution for the base image.\n\nMust be one of 'wolfi', 'debian', or 'bookworm'.\nIf omitted, defaults to 'debian' ('latest').\n"
             },
             "keep_pkg_tools": {
               "anyOf": [
@@ -554,17 +553,6 @@
           ],
           "description": "Optional. Defines the serde configuration.\n\nIf provided, the checkpointer will apply serde settings according to the configuration.\nIf omitted, no serde behavior is configured.\n\nThis configuration requires server version 0.5 or later to take effect.\n"
         },
-        "sweep_limit": {
-          "anyOf": [
-            {
-              "type": "integer"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "description": "Maximum number of threads to process per sweep iteration. Defaults to 1000."
-        },
         "ttl": {
           "anyOf": [
             {
@@ -629,9 +617,10 @@
         },
         "strategy": {
           "enum": [
-            "delete"
+            "delete",
+            "keep_latest"
           ],
-          "description": "Strategy to use for deleting checkpointed data.\n"
+          "description": "Action taken when a thread exceeds its TTL.\n\n"
         },
         "sweep_interval_minutes": {
           "anyOf": [
@@ -643,6 +632,17 @@
             }
           ],
           "description": "Interval in minutes between sweep iterations.\nIf omitted, a default interval will be used (typically ~ 5 minutes)."
+        },
+        "sweep_limit": {
+          "anyOf": [
+            {
+              "type": "integer"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "description": "Maximum number of threads to process per sweep iteration. Defaults to 1000."
         }
       },
       "required": []

libs/cli/scripts/bump-version.sh

@@ -0,0 +1,49 @@
+#!/usr/bin/env bash
+# Bumps the version across Cargo.toml and all npm package.json files.
+# Usage: ./scripts/bump-version.sh 0.3.0
+
+set -euo pipefail
+
+if [ $# -ne 1 ]; then
+    echo "Usage: $0 <version>"
+    echo "Example: $0 0.3.0"
+    exit 1
+fi
+
+VERSION="$1"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CLI_DIR="$(dirname "$SCRIPT_DIR")"
+
+echo "Bumping version to $VERSION"
+
+# Cargo.toml
+sed -i.bak "s/^version = \".*\"/version = \"$VERSION\"/" "$CLI_DIR/Cargo.toml"
+rm -f "$CLI_DIR/Cargo.toml.bak"
+echo "  Updated Cargo.toml"
+
+# All npm package.json files
+for pkg in "$CLI_DIR"/npm/*/package.json; do
+    # Update the package's own version
+    sed -i.bak "s/\"version\": \".*\"/\"version\": \"$VERSION\"/" "$pkg"
+    rm -f "$pkg.bak"
+
+    # Update optionalDependencies versions (main package only)
+    if grep -q "optionalDependencies" "$pkg" 2>/dev/null; then
+        sed -i.bak "s/\"@langchain\/langgraph-cli-\([^\"]*\)\": \"[^\"]*\"/\"@langchain\/langgraph-cli-\1\": \"$VERSION\"/" "$pkg"
+        rm -f "$pkg.bak"
+    fi
+
+    echo "  Updated $(basename "$(dirname "$pkg")")/package.json"
+done
+
+# Update Cargo.lock
+cd "$CLI_DIR"
+cargo update -p langgraph-cli 2>/dev/null || true
+echo "  Updated Cargo.lock"
+
+echo "Done! Version is now $VERSION"
+echo ""
+echo "Next steps:"
+echo "  1. git add -A && git commit -m 'chore(cli): bump version to $VERSION'"
+echo "  2. git tag cli-v$VERSION"
+echo "  3. git push origin main --tags"

libs/cli/src/analytics.rs

@@ -0,0 +1,50 @@
+use std::collections::HashMap;
+
+use crate::constants::{SUPABASE_PUBLIC_API_KEY, SUPABASE_URL};
+
+/// Fire-and-forget telemetry: log a CLI command invocation.
+///
+/// Spawns a background thread that POSTs anonymized usage data to Supabase.
+/// Respects the `LANGGRAPH_CLI_NO_ANALYTICS` environment variable -- if set to "1",
+/// no data is sent.
+pub fn log_command(command: &str, params: &HashMap<String, String>) {
+    if std::env::var("LANGGRAPH_CLI_NO_ANALYTICS").as_deref() == Ok("1") {
+        return;
+    }
+
+    let os_name = std::env::consts::OS.to_string();
+    let arch = std::env::consts::ARCH.to_string();
+    let cli_version = env!("CARGO_PKG_VERSION").to_string();
+    let command = command.to_string();
+    let params = params.clone();
+
+    std::thread::spawn(move || {
+        let data = serde_json::json!({
+            "os": os_name,
+            "os_version": arch,
+            "python_version": "rust",
+            "cli_version": cli_version,
+            "cli_command": command,
+            "params": params,
+        });
+
+        let url = format!("{SUPABASE_URL}/rest/v1/logs");
+
+        // Use a blocking reqwest client in this thread
+        let client = match reqwest::blocking::Client::builder()
+            .timeout(std::time::Duration::from_secs(5))
+            .build()
+        {
+            Ok(c) => c,
+            Err(_) => return,
+        };
+
+        let _ = client
+            .post(&url)
+            .header("Content-Type", "application/json")
+            .header("apikey", SUPABASE_PUBLIC_API_KEY)
+            .header("User-Agent", "Mozilla/5.0")
+            .body(data.to_string())
+            .send();
+    });
+}

libs/cli/src/commands/build_cmd.rs

@@ -0,0 +1,116 @@
+use std::collections::HashMap;
+use std::path::Path;
+
+use console::style;
+
+use crate::analytics;
+use crate::config::docker_tag::docker_tag;
+use crate::config::validate_config_file;
+use crate::docker::dockerfile::config_to_docker;
+use crate::exec::{run_command, run_command_streaming};
+use crate::progress::Progress;
+use crate::util::warn_non_wolfi_distro;
+
+/// Build a LangGraph API server Docker image.
+#[allow(clippy::too_many_arguments)]
+pub fn run(
+    config: &str,
+    tag: &str,
+    pull: bool,
+    base_image: Option<&str>,
+    api_version: Option<&str>,
+    install_command: Option<&str>,
+    build_command: Option<&str>,
+    docker_build_args: &[String],
+) -> Result<(), String> {
+    // Fire-and-forget analytics
+    let mut params = HashMap::new();
+    params.insert("pull".to_string(), pull.to_string());
+    analytics::log_command("build", &params);
+
+    // Check docker is available
+    if which::which("docker").is_err() {
+        return Err("Docker not installed".to_string());
+    }
+
+    let progress = Progress::new("Pulling...");
+
+    // Validate config
+    let config_path = Path::new(config);
+    let mut config_json = validate_config_file(config_path)?;
+    let config_value = serde_json::to_value(&config_json).unwrap();
+    warn_non_wolfi_distro(&config_value);
+
+    // Pull latest images if requested
+    if pull {
+        let image_tag = docker_tag(&config_json, base_image, api_version);
+        run_command("docker", &["pull", &image_tag], None, true)?;
+    }
+
+    progress.set_message("Building...");
+
+    // Determine build context
+    let is_js_project =
+        config_json.node_version.is_some() && config_json.python_version.is_none();
+
+    // For JS projects with install/build commands, use CWD; otherwise use config parent
+    let build_context = if is_js_project && (build_command.is_some() || install_command.is_some()) {
+        std::env::current_dir()
+            .map(|p| p.to_string_lossy().to_string())
+            .unwrap_or_else(|_| ".".to_string())
+    } else {
+        config_path
+            .parent()
+            .unwrap_or_else(|| Path::new("."))
+            .to_string_lossy()
+            .to_string()
+    };
+
+    // Generate Dockerfile
+    let (dockerfile_content, additional_contexts) = config_to_docker(
+        config_path,
+        &mut config_json,
+        base_image,
+        api_version,
+        install_command,
+        build_command,
+        Some(&build_context),
+        false, // no variable escaping for docker build
+    )?;
+
+    // Build docker build args
+    let mut args: Vec<String> = vec![
+        "build".to_string(),
+        "-f".to_string(),
+        "-".to_string(), // Dockerfile from stdin
+        "-t".to_string(),
+        tag.to_string(),
+    ];
+
+    // Add additional build contexts
+    for (name, path) in &additional_contexts {
+        args.push("--build-context".to_string());
+        args.push(format!("{name}={path}"));
+    }
+
+    // Add passthrough docker build args
+    for extra in docker_build_args {
+        args.push(extra.clone());
+    }
+
+    // Add build context as last arg
+    args.push(build_context);
+
+    progress.finish();
+
+    // Run docker build with streaming output
+    let args_refs: Vec<&str> = args.iter().map(|s| s.as_str()).collect();
+    run_command_streaming("docker", &args_refs, Some(&dockerfile_content), true)?;
+
+    eprintln!(
+        "{}",
+        style(format!("Successfully built image: {tag}")).green()
+    );
+
+    Ok(())
+}

libs/cli/src/commands/dev.rs

@@ -0,0 +1,196 @@
+use std::collections::HashMap;
+use std::path::Path;
+use std::process::Command;
+
+use console::style;
+
+use crate::analytics;
+use crate::config::validate_config_file;
+
+/// Find the Python interpreter, preferring python3 over python.
+fn find_python() -> Result<String, String> {
+    for candidate in &["python3", "python"] {
+        if which::which(candidate).is_ok() {
+            return Ok(candidate.to_string());
+        }
+    }
+    Err(
+        "Python not found. The `langgraph dev` command requires Python >= 3.11 with \
+         langgraph-cli[inmem] installed.\n\
+         Install with: pip install -U \"langgraph-cli[inmem]\""
+            .to_string(),
+    )
+}
+
+/// Run the LangGraph API server in development mode (in-memory, via Python subprocess).
+///
+/// This passes the config as a JSON object via stdin to a Python bootstrap script,
+/// avoiding any string interpolation into Python source code.
+#[allow(clippy::too_many_arguments)]
+pub fn run(
+    host: &str,
+    port: u16,
+    no_reload: bool,
+    config: &str,
+    n_jobs_per_worker: Option<u32>,
+    no_browser: bool,
+    debug_port: Option<u16>,
+    wait_for_client: bool,
+    studio_url: Option<&str>,
+    allow_blocking: bool,
+    tunnel: bool,
+    server_log_level: &str,
+) -> Result<(), String> {
+    // Fire-and-forget analytics
+    let mut params = HashMap::new();
+    params.insert("no_reload".to_string(), no_reload.to_string());
+    params.insert("no_browser".to_string(), no_browser.to_string());
+    params.insert("allow_blocking".to_string(), allow_blocking.to_string());
+    params.insert("tunnel".to_string(), tunnel.to_string());
+    analytics::log_command("dev", &params);
+
+    // Validate config
+    let config_path = Path::new(config);
+    let config_json = validate_config_file(config_path)?;
+
+    // Check for node_version -- in-mem server doesn't support JS graphs
+    if config_json.node_version.is_some() {
+        return Err(
+            "In-mem server for JS graphs is not supported in this version of the LangGraph CLI. \
+             Please use `npx @langchain/langgraph-cli` instead."
+                .to_string(),
+        );
+    }
+
+    let python = find_python()?;
+
+    // Pre-check that langgraph_api is importable
+    let check = Command::new(&python)
+        .args(["-c", "from langgraph_api.cli import run_server"])
+        .output();
+
+    match check {
+        Ok(output) if !output.status.success() => {
+            return Err(
+                "Required package 'langgraph-api' is not installed.\n\
+                 Please install it with:\n\n\
+                     pip install -U \"langgraph-cli[inmem]\"\n\n\
+                 Note: The in-mem server requires Python 3.11 or higher."
+                    .to_string(),
+            );
+        }
+        Err(_) => {
+            return Err(format!(
+                "Failed to run {python}. The `langgraph dev` command requires Python >= 3.11 with \
+                 langgraph-cli[inmem] installed.\n\
+                 Install with: pip install -U \"langgraph-cli[inmem]\""
+            ));
+        }
+        _ => {}
+    }
+
+    // Build a JSON config object to pass via stdin.
+    // This avoids interpolating user data into Python source code.
+    let dev_config = serde_json::json!({
+        "host": host,
+        "port": port,
+        "reload": !no_reload,
+        "open_browser": !no_browser,
+        "wait_for_client": wait_for_client,
+        "allow_blocking": allow_blocking,
+        "tunnel": tunnel,
+        "server_log_level": server_log_level,
+        "dependencies": config_json.dependencies,
+        "graphs": config_json.graphs,
+        "n_jobs_per_worker": n_jobs_per_worker,
+        "debug_port": debug_port,
+        "studio_url": studio_url,
+        "env": config_json.env,
+        "store": config_json.store,
+        "auth": config_json.auth,
+        "http": config_json.http,
+        "ui": config_json.ui,
+        "ui_config": config_json.ui_config,
+        "webhooks": config_json.webhooks,
+    });
+
+    // Python bootstrap: reads JSON from stdin, calls run_server
+    let python_code = r#"
+import sys, os, json, pathlib
+config = json.loads(sys.stdin.read())
+cwd = os.getcwd()
+sys.path.append(cwd)
+for dep in config.get('dependencies', []):
+    dep_path = pathlib.Path(cwd) / dep
+    if dep_path.is_dir() and dep_path.exists():
+        sys.path.append(str(dep_path))
+from langgraph_api.cli import run_server
+run_server(
+    config['host'],
+    config['port'],
+    config['reload'],
+    config['graphs'],
+    n_jobs_per_worker=config.get('n_jobs_per_worker'),
+    open_browser=config['open_browser'],
+    debug_port=config.get('debug_port'),
+    env=config.get('env'),
+    store=config.get('store'),
+    wait_for_client=config['wait_for_client'],
+    auth=config.get('auth'),
+    http=config.get('http'),
+    ui=config.get('ui'),
+    ui_config=config.get('ui_config'),
+    webhooks=config.get('webhooks'),
+    studio_url=config.get('studio_url'),
+    allow_blocking=config['allow_blocking'],
+    tunnel=config['tunnel'],
+    server_level=config['server_log_level'],
+)
+"#;
+
+    eprintln!(
+        "{}",
+        style("Starting LangGraph API server in development mode...").green()
+    );
+
+    // Spawn Python subprocess with config on stdin
+    let mut child = Command::new(&python)
+        .arg("-c")
+        .arg(python_code)
+        .current_dir(
+            config_path
+                .parent()
+                .unwrap_or_else(|| Path::new(".")),
+        )
+        .stdin(std::process::Stdio::piped())
+        .stdout(std::process::Stdio::inherit())
+        .stderr(std::process::Stdio::inherit())
+        .spawn()
+        .map_err(|e| format!("Failed to start Python: {e}"))?;
+
+    // Write JSON config to stdin
+    if let Some(ref mut stdin) = child.stdin {
+        use std::io::Write;
+        let json_bytes = dev_config.to_string();
+        stdin
+            .write_all(json_bytes.as_bytes())
+            .map_err(|e| format!("Failed to write config to Python stdin: {e}"))?;
+    }
+    // Drop stdin to signal EOF
+    drop(child.stdin.take());
+
+    let status = child
+        .wait()
+        .map_err(|e| format!("Failed to wait for Python: {e}"))?;
+
+    if !status.success() {
+        let code = status.code().unwrap_or(1);
+        if code == 130 {
+            // User interrupted with Ctrl-C
+            return Ok(());
+        }
+        return Err(format!("Development server exited with code {code}"));
+    }
+
+    Ok(())
+}

libs/cli/src/commands/dockerfile.rs

@@ -0,0 +1,232 @@
+use std::collections::HashMap;
+use std::path::Path;
+
+use console::style;
+
+use crate::analytics;
+use crate::config::validate_config_file;
+use crate::docker::capabilities::check_capabilities;
+use crate::docker::compose::compose_as_dict;
+use crate::docker::compose::dict_to_yaml;
+use crate::docker::dockerfile::config_to_docker;
+use crate::util::warn_non_wolfi_distro;
+
+/// Docker ignore file content.
+fn get_docker_ignore_content() -> &'static str {
+    "\
+# Ignore node_modules and other dependency directories
+node_modules
+bower_components
+vendor
+
+# Ignore logs and temporary files
+*.log
+*.tmp
+*.swp
+
+# Ignore .env files and other environment files
+.env
+.env.*
+*.local
+
+# Ignore git-related files
+.git
+.gitignore
+
+# Ignore Docker-related files and configs
+.dockerignore
+docker-compose.yml
+
+# Ignore build and cache directories
+dist
+build
+.cache
+__pycache__
+
+# Ignore IDE and editor configurations
+.vscode
+.idea
+*.sublime-project
+*.sublime-workspace
+.DS_Store  # macOS-specific
+
+# Ignore test and coverage files
+coverage
+*.coverage
+*.test.js
+*.spec.js
+tests
+"
+}
+
+/// Generate a Dockerfile for the LangGraph API server.
+pub fn run(
+    save_path: &str,
+    config: &str,
+    add_docker_compose: bool,
+    base_image: Option<&str>,
+    api_version: Option<&str>,
+) -> Result<(), String> {
+    // Fire-and-forget analytics
+    let mut params = HashMap::new();
+    params.insert(
+        "add_docker_compose".to_string(),
+        add_docker_compose.to_string(),
+    );
+    analytics::log_command("dockerfile", &params);
+
+    let save_path = Path::new(save_path);
+    let abs_save_path = if save_path.is_absolute() {
+        save_path.to_path_buf()
+    } else {
+        std::env::current_dir()
+            .unwrap_or_default()
+            .join(save_path)
+    };
+
+    eprintln!(
+        "{}",
+        style(format!("Validating configuration at path: {config}")).yellow()
+    );
+    let config_path = Path::new(config);
+    let mut config_json = validate_config_file(config_path)?;
+    let config_value = serde_json::to_value(&config_json).unwrap();
+    warn_non_wolfi_distro(&config_value);
+    eprintln!("{}", style("Configuration validated!").green());
+
+    eprintln!(
+        "{}",
+        style(format!(
+            "Generating Dockerfile at {}",
+            abs_save_path.display()
+        ))
+        .yellow()
+    );
+
+    let (dockerfile_content, additional_contexts) = config_to_docker(
+        config_path,
+        &mut config_json,
+        base_image,
+        api_version,
+        None,
+        None,
+        None,
+        false,
+    )?;
+
+    std::fs::write(&abs_save_path, &dockerfile_content)
+        .map_err(|e| format!("Failed to write Dockerfile: {e}"))?;
+    eprintln!("{}", style("Created: Dockerfile").green());
+
+    if !additional_contexts.is_empty() {
+        let ctx_str: Vec<String> = additional_contexts
+            .iter()
+            .map(|(k, v)| format!("{k}={v}"))
+            .collect();
+        eprintln!(
+            "{}",
+            style(format!(
+                "Run docker build with these additional build contexts `--build-context {}`",
+                ctx_str.join(",")
+            ))
+            .yellow()
+        );
+    }
+
+    if add_docker_compose {
+        let parent = abs_save_path.parent().unwrap_or(Path::new("."));
+
+        // Write .dockerignore
+        let dockerignore_path = parent.join(".dockerignore");
+        std::fs::write(&dockerignore_path, get_docker_ignore_content())
+            .map_err(|e| format!("Failed to write .dockerignore: {e}"))?;
+        eprintln!("{}", style("Created: .dockerignore").green());
+
+        // Generate docker-compose.yml
+        let capabilities = check_capabilities()?;
+        let mut compose_dict = compose_as_dict(
+            &capabilities,
+            8123,
+            None,
+            None,
+            None,
+            None,
+            base_image,
+            api_version,
+        );
+
+        // Add env_file and build context to langgraph-api service
+        if let Some(crate::docker::compose::YamlValue::Dict(ref mut services)) =
+            compose_dict.get_mut("services")
+        {
+            if let Some(crate::docker::compose::YamlValue::Dict(ref mut api_service)) =
+                services.get_mut("langgraph-api")
+            {
+                api_service.insert(
+                    "env_file".to_string(),
+                    crate::docker::compose::YamlValue::List(vec![".env".to_string()]),
+                );
+
+                let dockerfile_name = abs_save_path
+                    .file_name()
+                    .unwrap_or_default()
+                    .to_string_lossy()
+                    .to_string();
+                let mut build_config = indexmap::IndexMap::new();
+                build_config.insert(
+                    "context".to_string(),
+                    crate::docker::compose::YamlValue::String(".".to_string()),
+                );
+                build_config.insert(
+                    "dockerfile".to_string(),
+                    crate::docker::compose::YamlValue::String(dockerfile_name),
+                );
+                api_service.insert(
+                    "build".to_string(),
+                    crate::docker::compose::YamlValue::Dict(build_config),
+                );
+            }
+        }
+
+        let compose_yaml = dict_to_yaml(&compose_dict, 0);
+        let compose_path = parent.join("docker-compose.yml");
+        std::fs::write(&compose_path, &compose_yaml)
+            .map_err(|e| format!("Failed to write docker-compose.yml: {e}"))?;
+        eprintln!("{}", style("Created: docker-compose.yml").green());
+
+        // Create .env file if it doesn't exist
+        let env_path = parent.join(".env");
+        if !env_path.exists() {
+            let env_content = "\
+# Uncomment the following line to add your LangSmith API key
+# LANGSMITH_API_KEY=your-api-key
+# Or if you have a LangSmith Deployment license key, then uncomment the following line:
+# LANGGRAPH_CLOUD_LICENSE_KEY=your-license-key
+# Add any other environment variables go below...
+";
+            std::fs::write(&env_path, env_content)
+                .map_err(|e| format!("Failed to write .env: {e}"))?;
+            eprintln!("{}", style("Created: .env").green());
+        } else {
+            eprintln!(
+                "{}",
+                style("Skipped: .env. It already exists!").yellow()
+            );
+        }
+    }
+
+    eprintln!(
+        "{}",
+        style(format!(
+            "Files generated successfully at path {}!",
+            abs_save_path
+                .parent()
+                .unwrap_or(Path::new("."))
+                .display()
+        ))
+        .cyan()
+        .bold()
+    );
+
+    Ok(())
+}

libs/cli/src/commands/mod.rs

@@ -0,0 +1,5 @@
+pub mod build_cmd;
+pub mod dev;
+pub mod dockerfile;
+pub mod new;
+pub mod up;

libs/cli/src/commands/new.rs

@@ -0,0 +1,16 @@
+use std::collections::HashMap;
+
+use crate::analytics;
+use crate::templates;
+
+/// Create a new LangGraph project from a template.
+pub fn run(path: Option<&str>, template: Option<&str>) -> Result<(), String> {
+    // Fire-and-forget analytics
+    let mut params = HashMap::new();
+    if let Some(t) = template {
+        params.insert("template".to_string(), t.to_string());
+    }
+    analytics::log_command("new", &params);
+
+    templates::create_new(path, template)
+}

libs/cli/src/commands/up.rs

@@ -0,0 +1,198 @@
+use std::collections::HashMap;
+use std::path::Path;
+
+use console::style;
+
+use crate::analytics;
+use crate::config::docker_tag::{default_base_image, docker_tag};
+use crate::config::validate_config_file;
+use crate::docker::capabilities::{check_capabilities, ComposeType};
+use crate::docker::compose::compose;
+use crate::docker::dockerfile::config_to_compose;
+use crate::exec::{run_command, run_command_streaming_with_callback};
+use crate::progress::Progress;
+use crate::util::warn_non_wolfi_distro;
+
+/// Launch LangGraph API server with Docker Compose.
+#[allow(clippy::too_many_arguments)]
+pub fn run(
+    config: &str,
+    port: u16,
+    docker_compose: Option<&str>,
+    verbose: bool,
+    watch: bool,
+    recreate: bool,
+    pull: bool,
+    wait: bool,
+    debugger_port: Option<u16>,
+    debugger_base_url: Option<&str>,
+    postgres_uri: Option<&str>,
+    api_version: Option<&str>,
+    image: Option<&str>,
+    base_image: Option<&str>,
+) -> Result<(), String> {
+    // Fire-and-forget analytics
+    let mut params = HashMap::new();
+    params.insert("verbose".to_string(), verbose.to_string());
+    params.insert("watch".to_string(), watch.to_string());
+    params.insert("recreate".to_string(), recreate.to_string());
+    params.insert("pull".to_string(), pull.to_string());
+    params.insert("wait".to_string(), wait.to_string());
+    analytics::log_command("up", &params);
+
+    eprintln!("{}", style("Starting LangGraph API server...").green());
+    eprintln!(
+        "For local dev, requires env var LANGSMITH_API_KEY with access to LangSmith Deployment.\n\
+         For production use, requires a license key in env var LANGGRAPH_CLOUD_LICENSE_KEY."
+    );
+
+    let progress = Progress::new("Pulling...");
+
+    // Validate config
+    let config_path = Path::new(config);
+    let mut config_json = validate_config_file(config_path)?;
+    let config_value = serde_json::to_value(&config_json).unwrap();
+    warn_non_wolfi_distro(&config_value);
+
+    // Check docker capabilities
+    let capabilities = check_capabilities()?;
+
+    // Pull latest images if requested
+    if pull {
+        let tag = docker_tag(&config_json, base_image, api_version);
+        progress.set_message("Pulling...");
+        run_command("docker", &["pull", &tag], None, verbose)?;
+    }
+
+    // Generate compose YAML
+    let debugger_base_url_resolved = debugger_base_url
+        .map(|s| s.to_string())
+        .unwrap_or_else(|| format!("http://127.0.0.1:{port}"));
+
+    let mut compose_stdin = compose(
+        &capabilities,
+        port,
+        debugger_port,
+        Some(&debugger_base_url_resolved),
+        postgres_uri,
+        image,
+        base_image,
+        api_version,
+    );
+
+    // Append config-to-compose output (build instructions, env, watch sections)
+    let base_img = base_image
+        .map(|s| s.to_string())
+        .unwrap_or_else(|| default_base_image(&config_json));
+    let compose_config = config_to_compose(
+        config_path,
+        &mut config_json,
+        Some(&base_img),
+        api_version,
+        image,
+        watch,
+    )?;
+    compose_stdin.push_str(&compose_config);
+
+    // Build docker compose args
+    let mut args: Vec<String> = Vec::new();
+    args.push("--project-directory".to_string());
+    args.push(
+        config_path
+            .parent()
+            .unwrap_or_else(|| Path::new("."))
+            .to_string_lossy()
+            .to_string(),
+    );
+
+    if let Some(dc) = docker_compose {
+        args.push("-f".to_string());
+        args.push(dc.to_string());
+    }
+
+    // Read compose from stdin
+    args.push("-f".to_string());
+    args.push("-".to_string());
+
+    // Add up + options
+    args.push("up".to_string());
+    args.push("--remove-orphans".to_string());
+
+    if recreate {
+        args.push("--force-recreate".to_string());
+        args.push("--renew-anon-volumes".to_string());
+        // Try to remove the volume, ignore errors
+        let _ = run_command("docker", &["volume", "rm", "langgraph-data"], None, false);
+    }
+
+    if watch {
+        args.push("--watch".to_string());
+    }
+
+    if wait {
+        args.push("--wait".to_string());
+    } else {
+        args.push("--abort-on-container-exit".to_string());
+    }
+
+    progress.set_message("Building...");
+
+    // Determine compose command
+    let compose_cmd = match capabilities.compose_type {
+        ComposeType::Plugin => vec!["docker", "compose"],
+        ComposeType::Standalone => vec!["docker-compose"],
+    };
+
+    // Build final command args
+    let mut cmd_args: Vec<&str> = Vec::new();
+    if compose_cmd.len() > 1 {
+        // "docker compose ..."
+        cmd_args.extend_from_slice(&compose_cmd[1..]);
+    }
+    for a in &args {
+        cmd_args.push(a.as_str());
+    }
+
+    // Run docker compose with streaming output, intercepting stdout
+    // to detect startup and show Ready! URLs
+    let mut ready_printed = false;
+    let debugger_base_url_query = debugger_base_url
+        .map(|s| s.to_string())
+        .unwrap_or_else(|| format!("http://127.0.0.1:{port}"));
+
+    run_command_streaming_with_callback(
+        compose_cmd[0],
+        &cmd_args,
+        Some(&compose_stdin),
+        verbose,
+        |line| {
+            if !ready_printed {
+                if line.contains("unpacking to docker.io") {
+                    progress.set_message("Starting...");
+                } else if line.contains("Application startup complete") {
+                    progress.finish();
+                    ready_printed = true;
+
+                    let debugger_origin = if let Some(dp) = debugger_port {
+                        format!("http://localhost:{dp}")
+                    } else {
+                        "https://smith.langchain.com".to_string()
+                    };
+
+                    println!(
+                        "Ready!\n\
+                         - API: http://localhost:{port}\n\
+                         - Docs: http://localhost:{port}/docs\n\
+                         - LangGraph Studio: {debugger_origin}/studio/?baseUrl={debugger_base_url_query}"
+                    );
+                }
+            }
+        },
+    )?;
+
+    if !ready_printed {
+        progress.finish();
+    }
+
+    Ok(())
+}

libs/cli/src/config/docker_tag.rs

@@ -0,0 +1,458 @@
+use super::schema::Config;
+use crate::constants::DEFAULT_IMAGE_DISTRO;
+
+/// Get the default base image for a config.
+pub fn default_base_image(config: &Config) -> String {
+    if let Some(ref base) = config.base_image {
+        return base.clone();
+    }
+    if config.node_version.is_some() && config.python_version.is_none() {
+        "langchain/langgraphjs-api".to_string()
+    } else {
+        "langchain/langgraph-api".to_string()
+    }
+}
+
+/// Build the Docker image tag string.
+pub fn docker_tag(
+    config: &Config,
+    base_image: Option<&str>,
+    api_version: Option<&str>,
+) -> String {
+    let api_version = api_version
+        .map(|s| s.to_string())
+        .or_else(|| config.api_version.clone());
+    let base_image = base_image
+        .map(|s| s.to_string())
+        .unwrap_or_else(|| default_base_image(config));
+
+    let image_distro = config
+        .image_distro
+        .as_deref()
+        .unwrap_or(DEFAULT_IMAGE_DISTRO);
+    let distro_tag = if image_distro == DEFAULT_IMAGE_DISTRO {
+        String::new()
+    } else {
+        format!("-{image_distro}")
+    };
+
+    if let Some(ref tag) = config.internal_docker_tag {
+        return format!("{base_image}:{tag}");
+    }
+
+    // Build the standard tag format
+    let (language, version) = if config.node_version.is_some() && config.python_version.is_none() {
+        ("node", config.node_version.as_deref().unwrap_or("20"))
+    } else {
+        (
+            "py",
+            config
+                .python_version
+                .as_deref()
+                .unwrap_or(crate::constants::DEFAULT_PYTHON_VERSION),
+        )
+    };
+
+    let version_distro_tag = format!("{version}{distro_tag}");
+
+    if let Some(api_ver) = api_version {
+        format!("{base_image}:{api_ver}-{language}{version_distro_tag}")
+    } else if base_image.contains("/langgraph-server") && !base_image.contains(&version_distro_tag)
+    {
+        format!("{base_image}-{language}{version_distro_tag}")
+    } else {
+        format!("{base_image}:{version_distro_tag}")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::config::schema::Config;
+    use crate::config::validate_config;
+    use serde_json::json;
+
+    fn config_from_json(v: serde_json::Value) -> Config {
+        serde_json::from_value(v).unwrap()
+    }
+
+    #[test]
+    fn test_default_base_image_python() {
+        let config = Config {
+            python_version: Some("3.11".to_string()),
+            ..Default::default()
+        };
+        assert_eq!(default_base_image(&config), "langchain/langgraph-api");
+    }
+
+    #[test]
+    fn test_default_base_image_node() {
+        let config = Config {
+            node_version: Some("20".to_string()),
+            ..Default::default()
+        };
+        assert_eq!(default_base_image(&config), "langchain/langgraphjs-api");
+    }
+
+    #[test]
+    fn test_docker_tag_basic() {
+        let config = Config {
+            python_version: Some("3.11".to_string()),
+            ..Default::default()
+        };
+        assert_eq!(
+            docker_tag(&config, None, None),
+            "langchain/langgraph-api:3.11"
+        );
+    }
+
+    #[test]
+    fn test_docker_tag_with_api_version_basic() {
+        let config = Config {
+            python_version: Some("3.11".to_string()),
+            ..Default::default()
+        };
+        assert_eq!(
+            docker_tag(&config, None, Some("0.2.74")),
+            "langchain/langgraph-api:0.2.74-py3.11"
+        );
+    }
+
+    #[test]
+    fn test_docker_tag_wolfi() {
+        let config = Config {
+            python_version: Some("3.12".to_string()),
+            image_distro: Some("wolfi".to_string()),
+            ..Default::default()
+        };
+        assert_eq!(
+            docker_tag(&config, None, None),
+            "langchain/langgraph-api:3.12-wolfi"
+        );
+    }
+
+    #[test]
+    fn test_docker_tag_internal() {
+        let config = Config {
+            python_version: Some("3.11".to_string()),
+            internal_docker_tag: Some("custom-tag".to_string()),
+            ..Default::default()
+        };
+        assert_eq!(
+            docker_tag(&config, None, None),
+            "langchain/langgraph-api:custom-tag"
+        );
+    }
+
+    // ---------------------------------------------------------------
+    // Comprehensive tests ported from Python test_config.py
+    // ---------------------------------------------------------------
+
+    #[test]
+    fn test_docker_tag_image_distro() {
+        // Test 1: Default distro (debian) - no suffix
+        let cfg = config_from_json(json!({
+            "python_version": "3.11",
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"}
+        }));
+        let cfg = validate_config(cfg).unwrap();
+        assert_eq!(docker_tag(&cfg, None, None), "langchain/langgraph-api:3.11");
+
+        // Test 2: Explicit debian distro - same as default
+        let cfg = config_from_json(json!({
+            "python_version": "3.11",
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"},
+            "image_distro": "debian"
+        }));
+        let cfg = validate_config(cfg).unwrap();
+        assert_eq!(docker_tag(&cfg, None, None), "langchain/langgraph-api:3.11");
+
+        // Test 3: Wolfi distro with python
+        let cfg = config_from_json(json!({
+            "python_version": "3.11",
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"},
+            "image_distro": "wolfi"
+        }));
+        let cfg = validate_config(cfg).unwrap();
+        assert_eq!(
+            docker_tag(&cfg, None, None),
+            "langchain/langgraph-api:3.11-wolfi"
+        );
+
+        // Test 4: Node.js with default distro
+        let cfg = config_from_json(json!({
+            "node_version": "20",
+            "graphs": {"agent": "./agent.js:graph"}
+        }));
+        let cfg = validate_config(cfg).unwrap();
+        assert_eq!(
+            docker_tag(&cfg, None, None),
+            "langchain/langgraphjs-api:20"
+        );
+
+        // Test 5: Node.js with wolfi distro
+        let cfg = config_from_json(json!({
+            "node_version": "20",
+            "graphs": {"agent": "./agent.js:graph"},
+            "image_distro": "wolfi"
+        }));
+        let cfg = validate_config(cfg).unwrap();
+        assert_eq!(
+            docker_tag(&cfg, None, None),
+            "langchain/langgraphjs-api:20-wolfi"
+        );
+
+        // Test 6: Custom base image with wolfi
+        let cfg = config_from_json(json!({
+            "python_version": "3.12",
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"},
+            "image_distro": "wolfi",
+            "base_image": "my-registry/custom-image"
+        }));
+        let cfg = validate_config(cfg).unwrap();
+        assert_eq!(
+            docker_tag(&cfg, Some("my-registry/custom-image"), None),
+            "my-registry/custom-image:3.12-wolfi"
+        );
+    }
+
+    #[test]
+    fn test_docker_tag_multiplatform_with_distro() {
+        // Test 1: Python + Node with wolfi -> defaults to Python
+        let cfg = config_from_json(json!({
+            "python_version": "3.11",
+            "node_version": "20",
+            "dependencies": ["."],
+            "graphs": {"python": "./agent.py:graph", "js": "./agent.js:graph"},
+            "image_distro": "wolfi"
+        }));
+        let cfg = validate_config(cfg).unwrap();
+        assert_eq!(
+            docker_tag(&cfg, None, None),
+            "langchain/langgraph-api:3.11-wolfi"
+        );
+
+        // Test 2: Node-only with wolfi
+        let cfg = config_from_json(json!({
+            "node_version": "20",
+            "graphs": {"js": "./agent.js:graph"},
+            "image_distro": "wolfi"
+        }));
+        let cfg = validate_config(cfg).unwrap();
+        assert_eq!(
+            docker_tag(&cfg, None, None),
+            "langchain/langgraphjs-api:20-wolfi"
+        );
+    }
+
+    #[test]
+    fn test_docker_tag_different_python_versions_with_distro() {
+        for (ver, expected) in &[
+            ("3.11", "langchain/langgraph-api:3.11-wolfi"),
+            ("3.12", "langchain/langgraph-api:3.12-wolfi"),
+            ("3.13", "langchain/langgraph-api:3.13-wolfi"),
+        ] {
+            let cfg = config_from_json(json!({
+                "python_version": ver,
+                "dependencies": ["."],
+                "graphs": {"agent": "./agent.py:graph"},
+                "image_distro": "wolfi"
+            }));
+            let cfg = validate_config(cfg).unwrap();
+            assert_eq!(
+                docker_tag(&cfg, None, None),
+                *expected,
+                "Failed for Python {ver}"
+            );
+        }
+    }
+
+    #[test]
+    fn test_docker_tag_different_node_versions_with_distro() {
+        for (ver, expected) in &[
+            ("20", "langchain/langgraphjs-api:20-wolfi"),
+            ("21", "langchain/langgraphjs-api:21-wolfi"),
+            ("22", "langchain/langgraphjs-api:22-wolfi"),
+        ] {
+            let cfg = config_from_json(json!({
+                "node_version": ver,
+                "graphs": {"agent": "./agent.js:graph"},
+                "image_distro": "wolfi"
+            }));
+            let cfg = validate_config(cfg).unwrap();
+            assert_eq!(
+                docker_tag(&cfg, None, None),
+                *expected,
+                "Failed for Node.js {ver}"
+            );
+        }
+    }
+
+    /// Helper to run a single api_version test scenario with both in_config and as-argument modes.
+    fn run_api_version_test(
+        base_json: serde_json::Value,
+        api_version: &str,
+        base_image_arg: Option<&str>,
+        expected: &str,
+    ) {
+        // Mode 1: api_version passed as function argument (not in config)
+        {
+            let cfg = config_from_json(base_json.clone());
+            let cfg = validate_config(cfg).unwrap();
+            assert_eq!(
+                docker_tag(&cfg, base_image_arg, Some(api_version)),
+                expected,
+                "Failed with api_version as argument"
+            );
+        }
+
+        // Mode 2: api_version set in config (not passed as argument)
+        {
+            let mut json_val = base_json.clone();
+            json_val
+                .as_object_mut()
+                .unwrap()
+                .insert("api_version".to_string(), json!(api_version));
+            let cfg = config_from_json(json_val);
+            let cfg = validate_config(cfg).unwrap();
+            assert_eq!(
+                docker_tag(&cfg, base_image_arg, None),
+                expected,
+                "Failed with api_version in config"
+            );
+        }
+    }
+
+    #[test]
+    fn test_docker_tag_with_api_version() {
+        let version = "0.2.74";
+
+        // Test 1: Python config with api_version and default distro
+        run_api_version_test(
+            json!({
+                "python_version": "3.11",
+                "dependencies": ["."],
+                "graphs": {"agent": "./agent.py:graph"}
+            }),
+            version,
+            None,
+            "langchain/langgraph-api:0.2.74-py3.11",
+        );
+
+        // Test 2: Python config with api_version and wolfi distro
+        run_api_version_test(
+            json!({
+                "python_version": "3.12",
+                "dependencies": ["."],
+                "graphs": {"agent": "./agent.py:graph"},
+                "image_distro": "wolfi"
+            }),
+            version,
+            None,
+            "langchain/langgraph-api:0.2.74-py3.12-wolfi",
+        );
+
+        // Test 3: Node.js config with api_version and default distro
+        run_api_version_test(
+            json!({
+                "node_version": "20",
+                "graphs": {"agent": "./agent.js:graph"}
+            }),
+            version,
+            None,
+            "langchain/langgraphjs-api:0.2.74-node20",
+        );
+
+        // Test 4: Node.js config with api_version and wolfi distro
+        run_api_version_test(
+            json!({
+                "node_version": "20",
+                "graphs": {"agent": "./agent.js:graph"},
+                "image_distro": "wolfi"
+            }),
+            version,
+            None,
+            "langchain/langgraphjs-api:0.2.74-node20-wolfi",
+        );
+
+        // Test 5: Custom base image with api_version
+        run_api_version_test(
+            json!({
+                "python_version": "3.11",
+                "dependencies": ["."],
+                "graphs": {"agent": "./agent.py:graph"},
+                "base_image": "my-registry/custom-image"
+            }),
+            version,
+            Some("my-registry/custom-image"),
+            "my-registry/custom-image:0.2.74-py3.11",
+        );
+
+        // Test 6: Different Python versions with api_version
+        for py_ver in &["3.11", "3.12", "3.13"] {
+            let expected = format!("langchain/langgraph-api:{version}-py{py_ver}");
+            run_api_version_test(
+                json!({
+                    "python_version": py_ver,
+                    "dependencies": ["."],
+                    "graphs": {"agent": "./agent.py:graph"}
+                }),
+                version,
+                None,
+                &expected,
+            );
+        }
+
+        // Test 7: Without api_version should work as before
+        let cfg = config_from_json(json!({
+            "python_version": "3.11",
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"}
+        }));
+        let cfg = validate_config(cfg).unwrap();
+        assert_eq!(docker_tag(&cfg, None, None), "langchain/langgraph-api:3.11");
+
+        // Test 8: Multiplatform with api_version (should default to Python)
+        run_api_version_test(
+            json!({
+                "python_version": "3.11",
+                "node_version": "20",
+                "dependencies": ["."],
+                "graphs": {"python": "./agent.py:graph", "js": "./agent.js:graph"}
+            }),
+            version,
+            None,
+            "langchain/langgraph-api:0.2.74-py3.11",
+        );
+
+        // Test 9: _INTERNAL_docker_tag ignores api_version
+        // (can only test with api_version as argument since both in config is invalid)
+        let cfg = config_from_json(json!({
+            "python_version": "3.11",
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"},
+            "_INTERNAL_docker_tag": "internal-tag"
+        }));
+        let cfg = validate_config(cfg).unwrap();
+        assert_eq!(
+            docker_tag(&cfg, None, Some("0.2.74")),
+            "langchain/langgraph-api:internal-tag"
+        );
+
+        // Test 10: langgraph-server base image with api_version
+        run_api_version_test(
+            json!({
+                "python_version": "3.11",
+                "dependencies": ["."],
+                "graphs": {"agent": "./agent.py:graph"}
+            }),
+            version,
+            Some("langchain/langgraph-server"),
+            "langchain/langgraph-server:0.2.74-py3.11",
+        );
+    }
+}

libs/cli/src/config/local_deps.rs

@@ -0,0 +1,185 @@
+use std::collections::{HashMap, HashSet};
+use std::path::{Path, PathBuf};
+
+use indexmap::IndexMap;
+
+use super::schema::Config;
+use crate::constants::RESERVED_PACKAGE_NAMES;
+
+/// Container for referencing and managing local Python dependencies.
+#[derive(Debug, Clone)]
+pub struct LocalDeps {
+    /// (host_requirements_path, container_requirements_path)
+    pub pip_reqs: Vec<(PathBuf, String)>,
+    /// host_path -> (dependency_string, container_package_name)
+    pub real_pkgs: IndexMap<PathBuf, (String, String)>,
+    /// host_path -> (dependency_string, container_path)
+    pub faux_pkgs: IndexMap<PathBuf, (String, String)>,
+    /// If "." is in dependencies, use it as working_dir
+    pub working_dir: Option<String>,
+    /// Directories outside the config parent that need additional Docker build contexts
+    pub additional_contexts: Vec<PathBuf>,
+}
+
+impl Default for LocalDeps {
+    fn default() -> Self {
+        Self {
+            pip_reqs: Vec::new(),
+            real_pkgs: IndexMap::new(),
+            faux_pkgs: IndexMap::new(),
+            working_dir: None,
+            additional_contexts: Vec::new(),
+        }
+    }
+}
+
+/// Assemble local dependencies from config.
+pub fn assemble_local_deps(
+    config_path: &Path,
+    config: &Config,
+) -> Result<LocalDeps, String> {
+    let config_path = config_path
+        .canonicalize()
+        .map_err(|e| format!("Could not resolve config path: {e}"))?;
+    let config_parent = config_path.parent().unwrap();
+
+    let mut reserved: HashSet<String> = RESERVED_PACKAGE_NAMES
+        .iter()
+        .map(|s| s.to_string())
+        .collect();
+    let mut counter: HashMap<String, usize> = HashMap::new();
+
+    let check_reserved = |name: &str, ref_str: &str, reserved: &mut HashSet<String>| -> Result<(), String> {
+        if reserved.contains(name) {
+            return Err(format!(
+                "Package name '{name}' used in local dep '{ref_str}' is reserved. Rename the directory."
+            ));
+        }
+        reserved.insert(name.to_string());
+        Ok(())
+    };
+
+    let mut pip_reqs = Vec::new();
+    let mut real_pkgs = IndexMap::new();
+    let mut faux_pkgs = IndexMap::new();
+    let mut working_dir: Option<String> = None;
+    let mut additional_contexts = Vec::new();
+
+    for local_dep in &config.dependencies {
+        if !local_dep.starts_with('.') {
+            continue;
+        }
+
+        let resolved = (config_parent.join(local_dep))
+            .canonicalize()
+            .map_err(|_| format!("Could not find local dependency: {}", config_parent.join(local_dep).display()))?;
+
+        if !resolved.exists() {
+            return Err(format!("Could not find local dependency: {}", resolved.display()));
+        }
+        if !resolved.is_dir() {
+            return Err(format!(
+                "Local dependency must be a directory: {}",
+                resolved.display()
+            ));
+        }
+
+        if resolved != config_parent && !resolved.starts_with(config_parent) {
+            additional_contexts.push(resolved.clone());
+        }
+
+        let files: Vec<String> = std::fs::read_dir(&resolved)
+            .map_err(|e| format!("Could not read directory {}: {e}", resolved.display()))?
+            .filter_map(|entry| entry.ok().map(|e| e.file_name().to_string_lossy().to_string()))
+            .collect();
+
+        if files.contains(&"pyproject.toml".to_string())
+            || files.contains(&"setup.py".to_string())
+        {
+            // Real package
+            let dir_name = resolved
+                .file_name()
+                .unwrap()
+                .to_string_lossy()
+                .to_string();
+            let count = counter.entry(dir_name.clone()).or_insert(0);
+            let container_name = if *count > 0 {
+                format!("{}_{}", dir_name, count)
+            } else {
+                dir_name.clone()
+            };
+            *count += 1;
+
+            real_pkgs.insert(resolved.clone(), (local_dep.clone(), container_name.clone()));
+
+            if local_dep == "." {
+                working_dir = Some(format!("/deps/{container_name}"));
+            }
+        } else {
+            // Faux package
+            let dir_name = resolved
+                .file_name()
+                .unwrap()
+                .to_string_lossy()
+                .to_string();
+
+            if files.contains(&"__init__.py".to_string()) {
+                // Flat layout
+                if dir_name.contains('-') {
+                    return Err(format!(
+                        "Package name '{dir_name}' contains a hyphen. \
+                         Rename the directory to use it as flat-layout package."
+                    ));
+                }
+                check_reserved(&dir_name, local_dep, &mut reserved)?;
+                let container_path = format!("/deps/outer-{dir_name}/{dir_name}");
+                faux_pkgs.insert(resolved.clone(), (local_dep.clone(), container_path.clone()));
+                if local_dep == "." {
+                    working_dir = Some(container_path);
+                }
+            } else {
+                // Src layout
+                let container_path = format!("/deps/outer-{dir_name}/src");
+
+                for file in &files {
+                    let rfile = resolved.join(file);
+                    if rfile.is_dir() && file != "__pycache__" && !file.starts_with('.') {
+                        if let Ok(entries) = std::fs::read_dir(&rfile) {
+                            for subentry in entries.flatten() {
+                                let subname = subentry.file_name().to_string_lossy().to_string();
+                                if subname.ends_with(".py") {
+                                    check_reserved(file, local_dep, &mut reserved)?;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                faux_pkgs.insert(resolved.clone(), (local_dep.clone(), container_path.clone()));
+                if local_dep == "." {
+                    working_dir = Some(container_path);
+                }
+            }
+
+            // Check for requirements.txt
+            if files.contains(&"requirements.txt".to_string()) {
+                let rfile = resolved.join("requirements.txt");
+                let container_req_path = if let Some((_, ref cp)) = faux_pkgs.get(&resolved) {
+                    format!("{cp}/requirements.txt")
+                } else {
+                    format!("/deps/outer-{dir_name}/requirements.txt")
+                };
+                pip_reqs.push((rfile, container_req_path));
+            }
+        }
+    }
+
+    Ok(LocalDeps {
+        pip_reqs,
+        real_pkgs,
+        faux_pkgs,
+        working_dir,
+        additional_contexts,
+    })
+}

libs/cli/src/config/mod.rs

@@ -0,0 +1,849 @@
+pub mod docker_tag;
+pub mod local_deps;
+pub mod path_rewrite;
+pub mod schema;
+
+use std::path::Path;
+
+use schema::{Config, EnvConfig, GraphSpec, KeepPkgTools};
+
+use crate::constants::{
+    BUILD_TOOLS, DEFAULT_IMAGE_DISTRO, DEFAULT_NODE_VERSION, DEFAULT_PYTHON_VERSION,
+    MIN_NODE_VERSION, MIN_PYTHON_VERSION, VALID_DISTROS, VALID_PIP_INSTALLERS,
+};
+
+/// Check if a graph spec references a Node.js file based on extension.
+pub fn is_node_graph(spec: &GraphSpec) -> bool {
+    let path_str = match spec {
+        GraphSpec::Path(s) => s.as_str(),
+        GraphSpec::Dict(m) => match m.get("path").and_then(|v| v.as_str()) {
+            Some(p) => p,
+            None => return false,
+        },
+    };
+
+    let file_path = path_str.split(':').next().unwrap_or("");
+    matches!(
+        Path::new(file_path)
+            .extension()
+            .and_then(|e| e.to_str()),
+        Some("ts" | "mts" | "cts" | "js" | "mjs" | "cjs")
+    )
+}
+
+/// Parse a Python version string "major.minor" into (major, minor).
+fn parse_version(version_str: &str) -> Result<(u32, u32), String> {
+    let cleaned = version_str.split('-').next().unwrap_or(version_str);
+    let parts: Vec<&str> = cleaned.split('.').collect();
+    if parts.len() != 2 {
+        return Err(format!("Invalid version format: {version_str}"));
+    }
+    let major: u32 = parts[0]
+        .parse()
+        .map_err(|_| format!("Invalid version format: {version_str}"))?;
+    let minor: u32 = parts[1]
+        .parse()
+        .map_err(|_| format!("Invalid version format: {version_str}"))?;
+    Ok((major, minor))
+}
+
+/// Parse a Node.js version string (major only) into u32.
+fn parse_node_version(version_str: &str) -> Result<u32, String> {
+    if version_str.contains('.') {
+        return Err(format!(
+            "Invalid Node.js version format: {version_str}. Use major version only (e.g., '20')."
+        ));
+    }
+    version_str
+        .parse::<u32>()
+        .map_err(|_| format!("Invalid Node.js version format: {version_str}. Use major version only (e.g., '20')."))
+}
+
+/// Validate a configuration dictionary.
+pub fn validate_config(mut config: Config) -> Result<Config, String> {
+    let graphs = &config.graphs;
+
+    let some_node = graphs.values().any(|spec| is_node_graph(spec));
+    let some_python = graphs.values().any(|spec| !is_node_graph(spec));
+
+    // Set defaults for node_version and python_version
+    if config.node_version.is_none() && some_node {
+        config.node_version = Some(DEFAULT_NODE_VERSION.to_string());
+    }
+    if config.python_version.is_none() && some_python {
+        config.python_version = Some(DEFAULT_PYTHON_VERSION.to_string());
+    }
+
+    // Default image_distro
+    if config.image_distro.is_none() {
+        config.image_distro = Some(DEFAULT_IMAGE_DISTRO.to_string());
+    }
+
+    // Default pip_installer
+    if config.pip_installer.is_none() {
+        config.pip_installer = Some("auto".to_string());
+    }
+
+    // Default env
+    if config.env.is_none() {
+        config.env = Some(EnvConfig::default());
+    }
+
+    // Validate _INTERNAL_docker_tag vs api_version
+    if config.internal_docker_tag.is_some() && config.api_version.is_some() {
+        return Err("Cannot specify both _INTERNAL_docker_tag and api_version.".to_string());
+    }
+
+    // Validate api_version format
+    if let Some(ref api_version) = config.api_version {
+        let cleaned = api_version.split('-').next().unwrap_or(api_version);
+        let parts: Vec<&str> = cleaned.split('.').collect();
+        if parts.len() > 3 {
+            return Err("Version must be major or major.minor or major.minor.patch.".to_string());
+        }
+        for part in &parts {
+            part.parse::<u32>()
+                .map_err(|_| format!("Invalid version format: {api_version}"))?;
+        }
+    }
+
+    // Validate node_version
+    if let Some(ref node_version) = config.node_version {
+        let major = parse_node_version(node_version)?;
+        if major < MIN_NODE_VERSION {
+            return Err(format!(
+                "Node.js version {node_version} is not supported. Minimum required version is {MIN_NODE_VERSION}."
+            ));
+        }
+    }
+
+    // Validate python_version
+    if let Some(ref pyversion) = config.python_version {
+        let cleaned = pyversion.split('-').next().unwrap_or(pyversion);
+        if cleaned.split('.').count() != 2
+            || !cleaned.split('.').all(|p| p.chars().all(|c| c.is_ascii_digit()))
+        {
+            return Err(format!(
+                "Invalid Python version format: {pyversion}. \
+                 Use 'major.minor' format (e.g., '3.11'). \
+                 Patch version cannot be specified."
+            ));
+        }
+        if parse_version(pyversion)? < MIN_PYTHON_VERSION {
+            return Err(format!(
+                "Python version {pyversion} is not supported. \
+                 Minimum required version is {}.{}.",
+                MIN_PYTHON_VERSION.0, MIN_PYTHON_VERSION.1
+            ));
+        }
+
+        if config.dependencies.is_empty() {
+            return Err(
+                "No dependencies found in config. Add at least one dependency to 'dependencies' list."
+                    .to_string(),
+            );
+        }
+    }
+
+    // Validate graphs
+    if config.graphs.is_empty() {
+        return Err(
+            "No graphs found in config. Add at least one graph to 'graphs' dictionary."
+                .to_string(),
+        );
+    }
+
+    // Validate image_distro
+    if let Some(ref distro) = config.image_distro {
+        if distro == "bullseye" {
+            return Err(
+                "Bullseye images were deprecated in version 0.4.13. \
+                 Please use 'bookworm' or 'debian' instead."
+                    .to_string(),
+            );
+        }
+        if !VALID_DISTROS.contains(&distro.as_str()) {
+            return Err(format!(
+                "Invalid image_distro: '{distro}'. Must be one of 'debian', 'wolfi', or 'bookworm'."
+            ));
+        }
+    }
+
+    // Validate pip_installer
+    if let Some(ref pip_installer) = config.pip_installer {
+        if !VALID_PIP_INSTALLERS.contains(&pip_installer.as_str()) {
+            return Err(format!(
+                "Invalid pip_installer: '{pip_installer}'. Must be 'auto', 'pip', or 'uv'."
+            ));
+        }
+    }
+
+    // Validate auth config
+    if let Some(ref auth_conf) = config.auth {
+        if let Some(ref path) = auth_conf.path {
+            if !path.contains(':') {
+                return Err(format!(
+                    "Invalid auth.path format: '{path}'. \
+                     Must be in format './path/to/file.py:attribute_name'"
+                ));
+            }
+        }
+    }
+
+    // Validate encryption config
+    if let Some(ref encryption_conf) = config.encryption {
+        if let Some(ref path) = encryption_conf.path {
+            if !path.contains(':') {
+                return Err(format!(
+                    "Invalid encryption.path format: '{path}'. \
+                     Must be in format './path/to/file.py:attribute_name'"
+                ));
+            }
+        }
+    }
+
+    // Validate http config
+    if let Some(ref http_conf) = config.http {
+        if let Some(ref app) = http_conf.app {
+            if !app.contains(':') {
+                return Err(format!(
+                    "Invalid http.app format: '{app}'. \
+                     Must be in format './path/to/file.py:attribute_name'"
+                ));
+            }
+        }
+    }
+
+    // Validate keep_pkg_tools
+    if let Some(ref keep_pkg_tools) = config.keep_pkg_tools {
+        match keep_pkg_tools {
+            KeepPkgTools::List(tools) => {
+                for tool in tools {
+                    if !BUILD_TOOLS.contains(&tool.as_str()) {
+                        return Err(format!(
+                            "Invalid keep_pkg_tools: '{tool}'. \
+                             Must be one of 'pip', 'setuptools', 'wheel'."
+                        ));
+                    }
+                }
+            }
+            KeepPkgTools::Bool(_) => {}
+        }
+    }
+
+    Ok(config)
+}
+
+/// Load and validate a configuration file.
+pub fn validate_config_file(config_path: &Path) -> Result<Config, String> {
+    let content = std::fs::read_to_string(config_path)
+        .map_err(|e| format!("Could not read config file {}: {e}", config_path.display()))?;
+
+    let config: Config = serde_json::from_str(&content)
+        .map_err(|e| format!("Invalid JSON in config file {}: {e}", config_path.display()))?;
+
+    let validated = validate_config(config)?;
+
+    // Check package.json engines
+    if validated.node_version.is_some() {
+        let package_json_path = config_path.parent().unwrap().join("package.json");
+        if package_json_path.is_file() {
+            let pkg_content = std::fs::read_to_string(&package_json_path)
+                .map_err(|e| format!("Could not read package.json: {e}"))?;
+            let pkg: serde_json::Value = serde_json::from_str(&pkg_content).map_err(|_| {
+                format!(
+                    "Invalid package.json found in langgraph config directory {}: file is not valid JSON",
+                    package_json_path.display()
+                )
+            })?;
+
+            if let Some(engines) = pkg.get("engines").and_then(|e| e.as_object()) {
+                // Only 'node' engine is supported
+                if engines.keys().any(|k| k != "node") {
+                    return Err(format!(
+                        "Only 'node' engine is supported in package.json engines. Got engines: {:?}",
+                        engines.keys().collect::<Vec<_>>()
+                    ));
+                }
+                if let Some(node_version) = engines.get("node").and_then(|v| v.as_str()) {
+                    let major = parse_node_version(node_version)?;
+                    if major < MIN_NODE_VERSION {
+                        return Err(format!(
+                            "Node.js version in package.json engines must be >= {MIN_NODE_VERSION} \
+                             (major version only), got '{node_version}'. Minor/patch versions \
+                             (like '20.x.y') are not supported to prevent deployment issues \
+                             when new Node.js versions are released."
+                        ));
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(validated)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+    use std::io::Write;
+
+    fn config_from_json(val: serde_json::Value) -> Config {
+        serde_json::from_value::<Config>(val).unwrap()
+    }
+
+    // ---------------------------------------------------------------
+    // test_validate_config
+    // ---------------------------------------------------------------
+
+    #[test]
+    fn test_validate_config_minimal() {
+        let config = config_from_json(json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"}
+        }));
+        let result = validate_config(config).unwrap();
+        assert_eq!(result.python_version.as_deref(), Some("3.11"));
+        assert_eq!(result.node_version, None);
+        assert_eq!(result.pip_installer.as_deref(), Some("auto"));
+        assert_eq!(result.image_distro.as_deref(), Some("debian"));
+        assert_eq!(result.base_image, None);
+    }
+
+    #[test]
+    fn test_validate_config_full() {
+        let config = config_from_json(json!({
+            "python_version": "3.12",
+            "dependencies": [".", "langchain"],
+            "graphs": {"agent": "./agent.py:graph"},
+            "pip_config_file": "/etc/pip.conf",
+            "dockerfile_lines": ["RUN apt-get update"],
+            "env": ".env"
+        }));
+        let result = validate_config(config).unwrap();
+        assert_eq!(result.python_version.as_deref(), Some("3.12"));
+        assert_eq!(result.pip_config_file.as_deref(), Some("/etc/pip.conf"));
+        assert_eq!(result.dockerfile_lines, vec!["RUN apt-get update"]);
+        assert!(matches!(result.env, Some(EnvConfig::File(ref s)) if s == ".env"));
+    }
+
+    #[test]
+    fn test_validate_config_python_313() {
+        let config = config_from_json(json!({
+            "python_version": "3.13",
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"}
+        }));
+        let result = validate_config(config).unwrap();
+        assert_eq!(result.python_version.as_deref(), Some("3.13"));
+    }
+
+    #[test]
+    fn test_validate_config_python_39_error() {
+        let config = config_from_json(json!({
+            "python_version": "3.9",
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"}
+        }));
+        let err = validate_config(config).unwrap_err();
+        assert!(err.contains("Minimum required version"), "Expected 'Minimum required version' but got: {err}");
+    }
+
+    #[test]
+    fn test_validate_config_missing_dependencies() {
+        let config = config_from_json(json!({
+            "python_version": "3.11",
+            "graphs": {"agent": "./agent.py:graph"}
+        }));
+        let err = validate_config(config).unwrap_err();
+        assert!(err.contains("dependencies"), "Expected error about dependencies but got: {err}");
+    }
+
+    #[test]
+    fn test_validate_config_missing_graphs() {
+        let config = config_from_json(json!({
+            "dependencies": ["."]
+        }));
+        let err = validate_config(config).unwrap_err();
+        assert!(err.contains("graphs"), "Expected error about graphs but got: {err}");
+    }
+
+    #[test]
+    fn test_validate_config_python_version_with_patch() {
+        let config = config_from_json(json!({
+            "python_version": "3.11.0",
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"}
+        }));
+        let err = validate_config(config).unwrap_err();
+        assert!(err.contains("Invalid Python version format"), "Expected 'Invalid Python version format' but got: {err}");
+    }
+
+    #[test]
+    fn test_validate_config_python_version_major_only() {
+        let config = config_from_json(json!({
+            "python_version": "3",
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"}
+        }));
+        let err = validate_config(config).unwrap_err();
+        assert!(err.contains("Invalid Python version format"), "Expected 'Invalid Python version format' but got: {err}");
+    }
+
+    #[test]
+    fn test_validate_config_python_version_non_numeric() {
+        let config = config_from_json(json!({
+            "python_version": "abc.def",
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"}
+        }));
+        let err = validate_config(config).unwrap_err();
+        assert!(err.contains("Invalid Python version format"), "Expected 'Invalid Python version format' but got: {err}");
+    }
+
+    #[test]
+    fn test_validate_config_python_310_error() {
+        let config = config_from_json(json!({
+            "python_version": "3.10",
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"}
+        }));
+        let err = validate_config(config).unwrap_err();
+        assert!(err.contains("Minimum required version"), "Expected 'Minimum required version' but got: {err}");
+    }
+
+    #[test]
+    fn test_validate_config_python_312_slim() {
+        let config = config_from_json(json!({
+            "python_version": "3.12-slim",
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"}
+        }));
+        let result = validate_config(config).unwrap();
+        assert_eq!(result.python_version.as_deref(), Some("3.12-slim"));
+    }
+
+    #[test]
+    fn test_validate_config_http_app_no_colon() {
+        let config = config_from_json(json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"},
+            "http": {"app": "../../examples/my_app.py"}
+        }));
+        let err = validate_config(config).unwrap_err();
+        assert!(err.contains("Invalid http.app format"), "Expected 'Invalid http.app format' but got: {err}");
+    }
+
+    // ---------------------------------------------------------------
+    // test_validate_config_image_distro
+    // ---------------------------------------------------------------
+
+    #[test]
+    fn test_validate_config_image_distro_debian() {
+        let config = config_from_json(json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"},
+            "image_distro": "debian"
+        }));
+        let result = validate_config(config).unwrap();
+        assert_eq!(result.image_distro.as_deref(), Some("debian"));
+    }
+
+    #[test]
+    fn test_validate_config_image_distro_wolfi() {
+        let config = config_from_json(json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"},
+            "image_distro": "wolfi"
+        }));
+        let result = validate_config(config).unwrap();
+        assert_eq!(result.image_distro.as_deref(), Some("wolfi"));
+    }
+
+    #[test]
+    fn test_validate_config_image_distro_default() {
+        let config = config_from_json(json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"}
+        }));
+        let result = validate_config(config).unwrap();
+        assert_eq!(result.image_distro.as_deref(), Some("debian"));
+    }
+
+    #[test]
+    fn test_validate_config_image_distro_bullseye_error() {
+        let config = config_from_json(json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"},
+            "image_distro": "bullseye"
+        }));
+        let err = validate_config(config).unwrap_err();
+        assert!(err.contains("Bullseye images were deprecated"), "Expected 'Bullseye images were deprecated' but got: {err}");
+    }
+
+    #[test]
+    fn test_validate_config_image_distro_ubuntu_error() {
+        let config = config_from_json(json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"},
+            "image_distro": "ubuntu"
+        }));
+        let err = validate_config(config).unwrap_err();
+        assert!(err.contains("Invalid image_distro: 'ubuntu'"), "Expected \"Invalid image_distro: 'ubuntu'\" but got: {err}");
+    }
+
+    #[test]
+    fn test_validate_config_image_distro_alpine_error() {
+        let config = config_from_json(json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"},
+            "image_distro": "alpine"
+        }));
+        let err = validate_config(config).unwrap_err();
+        assert!(err.contains("Invalid image_distro: 'alpine'"), "Expected \"Invalid image_distro: 'alpine'\" but got: {err}");
+    }
+
+    #[test]
+    fn test_validate_config_node_with_wolfi() {
+        let config = config_from_json(json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.mts:graph"},
+            "image_distro": "wolfi"
+        }));
+        let result = validate_config(config).unwrap();
+        assert_eq!(result.image_distro.as_deref(), Some("wolfi"));
+        assert_eq!(result.node_version.as_deref(), Some("20"));
+    }
+
+    #[test]
+    fn test_validate_config_node_default_distro() {
+        let config = config_from_json(json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.mts:graph"}
+        }));
+        let result = validate_config(config).unwrap();
+        assert_eq!(result.image_distro.as_deref(), Some("debian"));
+    }
+
+    // ---------------------------------------------------------------
+    // test_validate_config_pip_installer
+    // ---------------------------------------------------------------
+
+    #[test]
+    fn test_validate_config_pip_installer_auto() {
+        let config = config_from_json(json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"},
+            "pip_installer": "auto"
+        }));
+        let result = validate_config(config).unwrap();
+        assert_eq!(result.pip_installer.as_deref(), Some("auto"));
+    }
+
+    #[test]
+    fn test_validate_config_pip_installer_pip() {
+        let config = config_from_json(json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"},
+            "pip_installer": "pip"
+        }));
+        let result = validate_config(config).unwrap();
+        assert_eq!(result.pip_installer.as_deref(), Some("pip"));
+    }
+
+    #[test]
+    fn test_validate_config_pip_installer_uv() {
+        let config = config_from_json(json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"},
+            "pip_installer": "uv"
+        }));
+        let result = validate_config(config).unwrap();
+        assert_eq!(result.pip_installer.as_deref(), Some("uv"));
+    }
+
+    #[test]
+    fn test_validate_config_pip_installer_default() {
+        let config = config_from_json(json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"}
+        }));
+        let result = validate_config(config).unwrap();
+        assert_eq!(result.pip_installer.as_deref(), Some("auto"));
+    }
+
+    #[test]
+    fn test_validate_config_pip_installer_conda_error() {
+        let config = config_from_json(json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"},
+            "pip_installer": "conda"
+        }));
+        let err = validate_config(config).unwrap_err();
+        assert!(err.contains("Invalid pip_installer: 'conda'"), "Expected \"Invalid pip_installer: 'conda'\" but got: {err}");
+        assert!(err.contains("Must be 'auto', 'pip', or 'uv'"), "Expected \"Must be 'auto', 'pip', or 'uv'\" but got: {err}");
+    }
+
+    #[test]
+    fn test_validate_config_pip_installer_invalid_error() {
+        let config = config_from_json(json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"},
+            "pip_installer": "invalid"
+        }));
+        let err = validate_config(config).unwrap_err();
+        assert!(err.contains("Invalid pip_installer: 'invalid'"), "Expected \"Invalid pip_installer: 'invalid'\" but got: {err}");
+    }
+
+    // ---------------------------------------------------------------
+    // test_validate_config_multiplatform
+    // ---------------------------------------------------------------
+
+    #[test]
+    fn test_validate_config_js_only_no_explicit_versions() {
+        let config = config_from_json(json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./js.mts:graph"}
+        }));
+        let result = validate_config(config).unwrap();
+        assert_eq!(result.node_version.as_deref(), Some("20"));
+        assert_eq!(result.python_version, None);
+    }
+
+    #[test]
+    fn test_validate_config_both_versions_explicit() {
+        let config = config_from_json(json!({
+            "python_version": "3.12",
+            "node_version": "22",
+            "dependencies": ["."],
+            "graphs": {
+                "agent_py": "./agent.py:graph",
+                "agent_js": "./agent.mts:graph"
+            }
+        }));
+        let result = validate_config(config).unwrap();
+        assert_eq!(result.python_version.as_deref(), Some("3.12"));
+        assert_eq!(result.node_version.as_deref(), Some("22"));
+    }
+
+    #[test]
+    fn test_validate_config_mixed_graphs_no_explicit_versions() {
+        let config = config_from_json(json!({
+            "dependencies": ["."],
+            "graphs": {
+                "agent_py": "./agent.py:graph",
+                "agent_js": "./agent.mts:graph"
+            }
+        }));
+        let result = validate_config(config).unwrap();
+        assert_eq!(result.node_version.as_deref(), Some("20"));
+        assert_eq!(result.python_version.as_deref(), Some("3.11"));
+    }
+
+    #[test]
+    fn test_validate_config_mixed_graphs_node_version_only() {
+        let config = config_from_json(json!({
+            "node_version": "22",
+            "dependencies": ["."],
+            "graphs": {
+                "agent_py": "./agent.py:graph",
+                "agent_js": "./agent.mts:graph"
+            }
+        }));
+        let result = validate_config(config).unwrap();
+        assert_eq!(result.node_version.as_deref(), Some("22"));
+        assert_eq!(result.python_version.as_deref(), Some("3.11"));
+    }
+
+    #[test]
+    fn test_validate_config_mixed_graphs_python_version_only() {
+        let config = config_from_json(json!({
+            "python_version": "3.12",
+            "dependencies": ["."],
+            "graphs": {
+                "agent_py": "./agent.py:graph",
+                "agent_js": "./agent.mts:graph"
+            }
+        }));
+        let result = validate_config(config).unwrap();
+        assert_eq!(result.node_version.as_deref(), Some("20"));
+        assert_eq!(result.python_version.as_deref(), Some("3.12"));
+    }
+
+    #[test]
+    fn test_validate_config_unknown_extension_assumes_python() {
+        let config = config_from_json(json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "local.workflow:graph"}
+        }));
+        let result = validate_config(config).unwrap();
+        assert_eq!(result.python_version.as_deref(), Some("3.11"));
+        assert_eq!(result.node_version, None);
+    }
+
+    // ---------------------------------------------------------------
+    // test_validate_config_encryption
+    // ---------------------------------------------------------------
+
+    #[test]
+    fn test_validate_config_encryption_valid() {
+        let config = config_from_json(json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"},
+            "encryption": {"path": "./encryption.py:encryption"}
+        }));
+        let result = validate_config(config).unwrap();
+        assert!(result.encryption.is_some());
+        assert_eq!(
+            result.encryption.as_ref().unwrap().path.as_deref(),
+            Some("./encryption.py:encryption")
+        );
+    }
+
+    #[test]
+    fn test_validate_config_encryption_no_colon_error() {
+        let config = config_from_json(json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"},
+            "encryption": {"path": "./encryption.py"}
+        }));
+        let err = validate_config(config).unwrap_err();
+        assert!(err.contains("Invalid encryption.path format"), "Expected 'Invalid encryption.path format' but got: {err}");
+    }
+
+    // ---------------------------------------------------------------
+    // test_validate_config_file
+    // ---------------------------------------------------------------
+
+    #[test]
+    fn test_validate_config_file_node_config() {
+        let tmp = tempfile::tempdir().unwrap();
+        let config_path = tmp.path().join("langgraph.json");
+        let config_json = json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.mts:graph"}
+        });
+        let mut f = std::fs::File::create(&config_path).unwrap();
+        write!(f, "{}", serde_json::to_string(&config_json).unwrap()).unwrap();
+        drop(f);
+
+        let result = validate_config_file(&config_path).unwrap();
+        assert_eq!(result.node_version.as_deref(), Some("20"));
+    }
+
+    #[test]
+    fn test_validate_config_file_with_valid_package_json() {
+        let tmp = tempfile::tempdir().unwrap();
+        let config_path = tmp.path().join("langgraph.json");
+        let config_json = json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.mts:graph"}
+        });
+        std::fs::write(&config_path, serde_json::to_string(&config_json).unwrap()).unwrap();
+
+        let pkg_path = tmp.path().join("package.json");
+        let pkg_json = json!({
+            "engines": {"node": "20"}
+        });
+        std::fs::write(&pkg_path, serde_json::to_string(&pkg_json).unwrap()).unwrap();
+
+        let result = validate_config_file(&config_path).unwrap();
+        assert_eq!(result.node_version.as_deref(), Some("20"));
+    }
+
+    #[test]
+    fn test_validate_config_file_package_json_minor_version_error() {
+        let tmp = tempfile::tempdir().unwrap();
+        let config_path = tmp.path().join("langgraph.json");
+        let config_json = json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.mts:graph"}
+        });
+        std::fs::write(&config_path, serde_json::to_string(&config_json).unwrap()).unwrap();
+
+        let pkg_path = tmp.path().join("package.json");
+        let pkg_json = json!({
+            "engines": {"node": "20.18"}
+        });
+        std::fs::write(&pkg_path, serde_json::to_string(&pkg_json).unwrap()).unwrap();
+
+        let err = validate_config_file(&config_path).unwrap_err();
+        assert!(err.contains("Use major version only"), "Expected 'Use major version only' but got: {err}");
+    }
+
+    #[test]
+    fn test_validate_config_file_package_json_old_node_error() {
+        let tmp = tempfile::tempdir().unwrap();
+        let config_path = tmp.path().join("langgraph.json");
+        let config_json = json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.mts:graph"}
+        });
+        std::fs::write(&config_path, serde_json::to_string(&config_json).unwrap()).unwrap();
+
+        let pkg_path = tmp.path().join("package.json");
+        let pkg_json = json!({
+            "engines": {"node": "18"}
+        });
+        std::fs::write(&pkg_path, serde_json::to_string(&pkg_json).unwrap()).unwrap();
+
+        let err = validate_config_file(&config_path).unwrap_err();
+        assert!(err.contains("must be >= 20"), "Expected 'must be >= 20' but got: {err}");
+    }
+
+    #[test]
+    fn test_validate_config_file_package_json_deno_engine_error() {
+        let tmp = tempfile::tempdir().unwrap();
+        let config_path = tmp.path().join("langgraph.json");
+        let config_json = json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.mts:graph"}
+        });
+        std::fs::write(&config_path, serde_json::to_string(&config_json).unwrap()).unwrap();
+
+        let pkg_path = tmp.path().join("package.json");
+        let pkg_json = json!({
+            "engines": {"node": "20", "deno": "1.0"}
+        });
+        std::fs::write(&pkg_path, serde_json::to_string(&pkg_json).unwrap()).unwrap();
+
+        let err = validate_config_file(&config_path).unwrap_err();
+        assert!(err.contains("Only 'node' engine is supported"), "Expected 'Only node engine is supported' but got: {err}");
+    }
+
+    #[test]
+    fn test_validate_config_file_invalid_package_json() {
+        let tmp = tempfile::tempdir().unwrap();
+        let config_path = tmp.path().join("langgraph.json");
+        let config_json = json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.mts:graph"}
+        });
+        std::fs::write(&config_path, serde_json::to_string(&config_json).unwrap()).unwrap();
+
+        let pkg_path = tmp.path().join("package.json");
+        std::fs::write(&pkg_path, "this is not valid json!!!").unwrap();
+
+        let err = validate_config_file(&config_path).unwrap_err();
+        assert!(err.contains("Invalid package.json"), "Expected 'Invalid package.json' but got: {err}");
+    }
+
+    #[test]
+    fn test_validate_config_file_python_ignores_bad_package_json() {
+        let tmp = tempfile::tempdir().unwrap();
+        let config_path = tmp.path().join("langgraph.json");
+        let config_json = json!({
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"}
+        });
+        std::fs::write(&config_path, serde_json::to_string(&config_json).unwrap()).unwrap();
+
+        // Write a bad package.json - should be ignored for Python-only config
+        let pkg_path = tmp.path().join("package.json");
+        std::fs::write(&pkg_path, "this is not valid json!!!").unwrap();
+
+        let result = validate_config_file(&config_path).unwrap();
+        assert_eq!(result.python_version.as_deref(), Some("3.11"));
+    }
+}

libs/cli/src/config/path_rewrite.rs

@@ -0,0 +1,324 @@
+use std::path::Path;
+
+use super::local_deps::LocalDeps;
+use super::schema::{Config, GraphSpec};
+
+/// Remap each graph's import path to the correct in-container path.
+pub fn update_graph_paths(
+    config_path: &Path,
+    config: &mut Config,
+    local_deps: &LocalDeps,
+) -> Result<(), String> {
+    let config_parent = config_path.parent().unwrap();
+    let graph_ids: Vec<String> = config.graphs.keys().cloned().collect();
+
+    for graph_id in graph_ids {
+        let import_str = {
+            let spec = config.graphs.get(&graph_id).unwrap();
+            match spec {
+                GraphSpec::Path(s) => s.clone(),
+                GraphSpec::Dict(m) => {
+                    if let Some(path_val) = m.get("path") {
+                        path_val
+                            .as_str()
+                            .ok_or_else(|| {
+                                format!("Graph '{graph_id}' path must be a string")
+                            })?
+                            .to_string()
+                    } else {
+                        return Err(format!(
+                            "Graph '{graph_id}' must contain a 'path' key if it is a dictionary."
+                        ));
+                    }
+                }
+            }
+        };
+
+        let (module_str, attr_str) = match import_str.split_once(':') {
+            Some((m, a)) if !m.is_empty() && !a.is_empty() => (m, a),
+            _ => {
+                return Err(format!(
+                    "Import string \"{import_str}\" must be in format \"<module>:<attribute>\"."
+                ));
+            }
+        };
+
+        // Check for file path (contains / or \)
+        if module_str.contains('/') || module_str.contains('\\') {
+            let resolved = config_parent
+                .join(module_str)
+                .canonicalize()
+                .map_err(|_| format!("Could not find local module: {}", config_parent.join(module_str).display()))?;
+
+            if !resolved.exists() {
+                return Err(format!("Could not find local module: {}", resolved.display()));
+            }
+            if !resolved.is_file() {
+                return Err(format!("Local module must be a file: {}", resolved.display()));
+            }
+
+            let mut new_module = None;
+
+            // Check real packages
+            for (path, (_, container_name)) in &local_deps.real_pkgs {
+                if resolved.starts_with(path) {
+                    if let Ok(relative) = resolved.strip_prefix(path) {
+                        let container_path =
+                            format!("/deps/{}/{}", container_name, relative.to_string_lossy().replace('\\', "/"));
+                        new_module = Some(container_path);
+                        break;
+                    }
+                }
+            }
+
+            // Check faux packages
+            if new_module.is_none() {
+                for (faux_path, (_, destpath)) in &local_deps.faux_pkgs {
+                    if resolved.starts_with(faux_path) {
+                        if let Ok(relative) = resolved.strip_prefix(faux_path) {
+                            new_module = Some(format!(
+                                "{}/{}",
+                                destpath,
+                                relative.to_string_lossy().replace('\\', "/")
+                            ));
+                            break;
+                        }
+                    }
+                }
+            }
+
+            if let Some(new_mod) = new_module {
+                let new_path = format!("{new_mod}:{attr_str}");
+                config.graphs.get_mut(&graph_id).unwrap().set_path(new_path);
+            } else {
+                return Err(format!(
+                    "Module '{import_str}' not found in 'dependencies' list. \
+                     Add its containing package to 'dependencies' list."
+                ));
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Update auth.path to use Docker container paths.
+pub fn update_auth_path(
+    config_path: &Path,
+    config: &mut Config,
+    local_deps: &LocalDeps,
+) -> Result<(), String> {
+    let auth_conf = match config.auth.as_mut() {
+        Some(a) => a,
+        None => return Ok(()),
+    };
+    let path_str = match auth_conf.path.as_ref() {
+        Some(p) => p.clone(),
+        None => return Ok(()),
+    };
+
+    let (module_str, attr_str) = match path_str.split_once(':') {
+        Some((m, a)) => (m, a),
+        None => return Ok(()),
+    };
+
+    if !module_str.starts_with('.') {
+        return Ok(());
+    }
+
+    let config_parent = config_path.parent().unwrap();
+    let resolved = config_parent
+        .join(module_str)
+        .canonicalize()
+        .map_err(|_| format!("Auth file not found: {} (from {path_str})", config_parent.join(module_str).display()))?;
+
+    if !resolved.is_file() {
+        return Err(format!("Auth path must be a file: {}", resolved.display()));
+    }
+
+    // Check faux packages first
+    for (faux_path, (_, destpath)) in &local_deps.faux_pkgs {
+        if resolved.starts_with(faux_path) {
+            if let Ok(relative) = resolved.strip_prefix(faux_path) {
+                auth_conf.path = Some(format!(
+                    "{}/{}:{attr_str}",
+                    destpath,
+                    relative.to_string_lossy()
+                ));
+                return Ok(());
+            }
+        }
+    }
+
+    // Check real packages
+    for (real_path, _) in &local_deps.real_pkgs {
+        if resolved.starts_with(real_path) {
+            if let Ok(relative) = resolved.strip_prefix(real_path) {
+                let dir_name = real_path.file_name().unwrap().to_string_lossy();
+                auth_conf.path = Some(format!(
+                    "/deps/{}/{}:{attr_str}",
+                    dir_name,
+                    relative.to_string_lossy()
+                ));
+                return Ok(());
+            }
+        }
+    }
+
+    Err(format!(
+        "Auth file '{}' not covered by dependencies.\n\
+         Add its parent directory to the 'dependencies' array in your config.",
+        resolved.display()
+    ))
+}
+
+/// Update encryption.path to use Docker container paths.
+pub fn update_encryption_path(
+    config_path: &Path,
+    config: &mut Config,
+    local_deps: &LocalDeps,
+) -> Result<(), String> {
+    let encryption_conf = match config.encryption.as_mut() {
+        Some(e) => e,
+        None => return Ok(()),
+    };
+    let path_str = match encryption_conf.path.as_ref() {
+        Some(p) => p.clone(),
+        None => return Ok(()),
+    };
+
+    let (module_str, attr_str) = match path_str.split_once(':') {
+        Some((m, a)) => (m, a),
+        None => return Ok(()),
+    };
+
+    if !module_str.starts_with('.') {
+        return Ok(());
+    }
+
+    let config_parent = config_path.parent().unwrap();
+    let resolved = config_parent
+        .join(module_str)
+        .canonicalize()
+        .map_err(|_| {
+            format!(
+                "Encryption file not found: {} (from {path_str})",
+                config_parent.join(module_str).display()
+            )
+        })?;
+
+    if !resolved.is_file() {
+        return Err(format!(
+            "Encryption path must be a file: {}",
+            resolved.display()
+        ));
+    }
+
+    for (faux_path, (_, destpath)) in &local_deps.faux_pkgs {
+        if resolved.starts_with(faux_path) {
+            if let Ok(relative) = resolved.strip_prefix(faux_path) {
+                encryption_conf.path = Some(format!(
+                    "{}/{}:{attr_str}",
+                    destpath,
+                    relative.to_string_lossy()
+                ));
+                return Ok(());
+            }
+        }
+    }
+
+    for (real_path, _) in &local_deps.real_pkgs {
+        if resolved.starts_with(real_path) {
+            if let Ok(relative) = resolved.strip_prefix(real_path) {
+                let dir_name = real_path.file_name().unwrap().to_string_lossy();
+                encryption_conf.path = Some(format!(
+                    "/deps/{}/{}:{attr_str}",
+                    dir_name,
+                    relative.to_string_lossy()
+                ));
+                return Ok(());
+            }
+        }
+    }
+
+    Err(format!(
+        "Encryption file '{}' not covered by dependencies.\n\
+         Add its parent directory to the 'dependencies' array in your config.",
+        resolved.display()
+    ))
+}
+
+/// Update the HTTP app path to point to the correct location in the Docker container.
+pub fn update_http_app_path(
+    config_path: &Path,
+    config: &mut Config,
+    local_deps: &LocalDeps,
+) -> Result<(), String> {
+    let http_config = match config.http.as_mut() {
+        Some(h) => h,
+        None => return Ok(()),
+    };
+    let app_str = match http_config.app.as_ref() {
+        Some(a) => a.clone(),
+        None => return Ok(()),
+    };
+
+    let (module_str, attr_str) = match app_str.split_once(':') {
+        Some((m, a)) if !m.is_empty() && !a.is_empty() => (m, a),
+        _ => {
+            return Err(format!(
+                "Import string \"{app_str}\" must be in format \"<module>:<attribute>\"."
+            ));
+        }
+    };
+
+    if !module_str.contains('/') && !module_str.contains('\\') {
+        return Ok(());
+    }
+
+    let config_parent = config_path.parent().unwrap();
+    let resolved = config_parent
+        .join(module_str)
+        .canonicalize()
+        .map_err(|_| format!("Could not find HTTP app module: {}", config_parent.join(module_str).display()))?;
+
+    if !resolved.is_file() {
+        return Err(format!(
+            "HTTP app module must be a file: {}",
+            resolved.display()
+        ));
+    }
+
+    // Check real packages
+    for (path, (_, _name)) in &local_deps.real_pkgs {
+        if resolved.starts_with(path) {
+            if let Ok(relative) = resolved.strip_prefix(path) {
+                let dir_name = path.file_name().unwrap().to_string_lossy();
+                http_config.app = Some(format!(
+                    "/deps/{}/{}:{attr_str}",
+                    dir_name,
+                    relative.to_string_lossy().replace('\\', "/")
+                ));
+                return Ok(());
+            }
+        }
+    }
+
+    // Check faux packages
+    for (faux_path, (_, destpath)) in &local_deps.faux_pkgs {
+        if resolved.starts_with(faux_path) {
+            if let Ok(relative) = resolved.strip_prefix(faux_path) {
+                http_config.app = Some(format!(
+                    "{}/{}:{attr_str}",
+                    destpath,
+                    relative.to_string_lossy().replace('\\', "/")
+                ));
+                return Ok(());
+            }
+        }
+    }
+
+    Err(format!(
+        "HTTP app module '{app_str}' not found in 'dependencies' list. \
+         Add its containing package to 'dependencies' list."
+    ))
+}

libs/cli/src/config/schema.rs

@@ -0,0 +1,186 @@
+use indexmap::IndexMap;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+/// Top-level config for langgraph-cli deployment.
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct Config {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub python_version: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub node_version: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub api_version: Option<String>,
+
+    #[serde(rename = "_INTERNAL_docker_tag", skip_serializing_if = "Option::is_none")]
+    pub internal_docker_tag: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub base_image: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub image_distro: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pip_config_file: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pip_installer: Option<String>,
+
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub dockerfile_lines: Vec<String>,
+
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub dependencies: Vec<String>,
+
+    #[serde(default, skip_serializing_if = "IndexMap::is_empty")]
+    pub graphs: IndexMap<String, GraphSpec>,
+
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub env: Option<EnvConfig>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub store: Option<Value>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub auth: Option<AuthConfig>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub encryption: Option<EncryptionConfig>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub http: Option<HttpConfig>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub webhooks: Option<Value>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub checkpointer: Option<Value>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ui: Option<IndexMap<String, String>>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ui_config: Option<Value>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub keep_pkg_tools: Option<KeepPkgTools>,
+}
+
+/// Graph specification: either a string path or a dict with a "path" key.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum GraphSpec {
+    Path(String),
+    Dict(IndexMap<String, Value>),
+}
+
+impl GraphSpec {
+    pub fn set_path(&mut self, new_path: String) {
+        match self {
+            GraphSpec::Path(s) => *s = new_path,
+            GraphSpec::Dict(m) => {
+                m.insert("path".to_string(), Value::String(new_path));
+            }
+        }
+    }
+}
+
+/// Environment config: either a dict of key-value pairs or a path to an env file.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum EnvConfig {
+    Dict(IndexMap<String, String>),
+    File(String),
+}
+
+impl Default for EnvConfig {
+    fn default() -> Self {
+        EnvConfig::Dict(IndexMap::new())
+    }
+}
+
+/// Auth configuration.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AuthConfig {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub disable_studio_auth: Option<bool>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub openapi: Option<Value>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cache: Option<Value>,
+}
+
+/// Encryption configuration.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct EncryptionConfig {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+}
+
+/// HTTP configuration.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct HttpConfig {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub app: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub disable_assistants: Option<bool>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub disable_threads: Option<bool>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub disable_runs: Option<bool>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub disable_store: Option<bool>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub disable_mcp: Option<bool>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub disable_a2a: Option<bool>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub disable_meta: Option<bool>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub disable_ui: Option<bool>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub disable_webhooks: Option<bool>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cors: Option<Value>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub configurable_headers: Option<Value>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub logging_headers: Option<Value>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub middleware_order: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub enable_custom_route_auth: Option<bool>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mount_prefix: Option<String>,
+}
+
+/// Keep package tools config: either a boolean or a list of tool names.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum KeepPkgTools {
+    Bool(bool),
+    List(Vec<String>),
+}

libs/cli/src/constants.rs

@@ -0,0 +1,35 @@
+pub const MIN_NODE_VERSION: u32 = 20;
+pub const DEFAULT_NODE_VERSION: u32 = 20;
+
+pub const MIN_PYTHON_VERSION: (u32, u32) = (3, 11);
+pub const DEFAULT_PYTHON_VERSION: &str = "3.11";
+
+pub const DEFAULT_IMAGE_DISTRO: &str = "debian";
+
+pub const BUILD_TOOLS: &[&str] = &["pip", "setuptools", "wheel"];
+
+// Analytics
+pub const SUPABASE_PUBLIC_API_KEY: &str = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Imt6cmxwcG9qaW5wY3l5YWlweG5iIiwicm9sZSI6ImFub24iLCJpYXQiOjE3MTkyNTc1NzksImV4cCI6MjAzNDgzMzU3OX0.kkVOlLz3BxemA5nP-vat3K4qRtrDuO4SwZSR_htcX9c";
+pub const SUPABASE_URL: &str = "https://kzrlppojinpcyyaipxnb.supabase.co";
+
+pub const DEFAULT_POSTGRES_URI: &str =
+    "postgres://postgres:postgres@langgraph-postgres:5432/postgres?sslmode=disable";
+
+pub const VALID_DISTROS: &[&str] = &["debian", "wolfi", "bookworm"];
+pub const VALID_PIP_INSTALLERS: &[&str] = &["auto", "pip", "uv"];
+
+pub const RESERVED_PACKAGE_NAMES: &[&str] = &[
+    "src",
+    "langgraph-api",
+    "langgraph_api",
+    "langgraph",
+    "langchain-core",
+    "langchain_core",
+    "pydantic",
+    "orjson",
+    "fastapi",
+    "uvicorn",
+    "psycopg",
+    "httpx",
+    "langsmith",
+];

libs/cli/src/docker/capabilities.rs

@@ -0,0 +1,185 @@
+use std::process::Command;
+
+/// Semantic version tuple.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Version {
+    pub major: u32,
+    pub minor: u32,
+    pub patch: u32,
+}
+
+impl Version {
+    pub fn new(major: u32, minor: u32, patch: u32) -> Self {
+        Self {
+            major,
+            minor,
+            patch,
+        }
+    }
+}
+
+/// Type of Docker Compose installation.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ComposeType {
+    Plugin,
+    Standalone,
+}
+
+/// Docker capabilities detected on the system.
+#[derive(Debug, Clone)]
+pub struct DockerCapabilities {
+    #[allow(dead_code)]
+    pub version_docker: Version,
+    #[allow(dead_code)]
+    pub version_compose: Version,
+    pub healthcheck_start_interval: bool,
+    pub compose_type: ComposeType,
+}
+
+/// Parse a version string like "1.2.3", "v1.2.3-alpha", etc.
+pub fn parse_version(version: &str) -> Version {
+    let cleaned = version.trim();
+    let parts: Vec<&str> = cleaned.split('.').collect();
+
+    let parse_part = |s: &str| -> u32 {
+        let s = s.trim_start_matches('v');
+        let s = s.split('-').next().unwrap_or(s);
+        let s = s.split('+').next().unwrap_or(s);
+        s.parse().unwrap_or(0)
+    };
+
+    match parts.len() {
+        1 => Version::new(parse_part(parts[0]), 0, 0),
+        2 => Version::new(parse_part(parts[0]), parse_part(parts[1]), 0),
+        _ => Version::new(
+            parse_part(parts[0]),
+            parse_part(parts[1]),
+            parse_part(parts[2]),
+        ),
+    }
+}
+
+/// Check Docker capabilities on the system.
+pub fn check_capabilities() -> Result<DockerCapabilities, String> {
+    // Check docker is available
+    if which::which("docker").is_err() {
+        return Err("Docker not installed".to_string());
+    }
+
+    // Get docker info
+    let output = Command::new("docker")
+        .args(["info", "-f", "{{json .}}"])
+        .output()
+        .map_err(|_| "Docker not installed or not running".to_string())?;
+
+    if !output.status.success() {
+        return Err("Docker not installed or not running".to_string());
+    }
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let info: serde_json::Value =
+        serde_json::from_str(&stdout).map_err(|_| "Docker not installed or not running".to_string())?;
+
+    let server_version = info
+        .get("ServerVersion")
+        .and_then(|v| v.as_str())
+        .ok_or("Docker not running")?;
+
+    if server_version.is_empty() {
+        return Err("Docker not running".to_string());
+    }
+
+    // Try to find compose as plugin
+    let (compose_version_str, compose_type) = if let Some(plugins) = info
+        .get("ClientInfo")
+        .and_then(|ci| ci.get("Plugins"))
+        .and_then(|p| p.as_array())
+    {
+        if let Some(compose) = plugins
+            .iter()
+            .find(|p| p.get("Name").and_then(|n| n.as_str()) == Some("compose"))
+        {
+            let version = compose
+                .get("Version")
+                .and_then(|v| v.as_str())
+                .unwrap_or("0.0.0");
+            (version.to_string(), ComposeType::Plugin)
+        } else {
+            get_standalone_compose_version()?
+        }
+    } else {
+        get_standalone_compose_version()?
+    };
+
+    let docker_version = parse_version(server_version);
+    let compose_version = parse_version(&compose_version_str);
+
+    Ok(DockerCapabilities {
+        version_docker: docker_version,
+        version_compose: compose_version,
+        healthcheck_start_interval: docker_version >= Version::new(25, 0, 0),
+        compose_type,
+    })
+}
+
+fn get_standalone_compose_version() -> Result<(String, ComposeType), String> {
+    if which::which("docker-compose").is_err() {
+        return Err("Docker Compose not installed".to_string());
+    }
+
+    let output = Command::new("docker-compose")
+        .args(["--version", "--short"])
+        .output()
+        .map_err(|_| "Docker Compose not installed".to_string())?;
+
+    let version = String::from_utf8_lossy(&output.stdout).trim().to_string();
+    Ok((version, ComposeType::Standalone))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_version_basic() {
+        assert_eq!(parse_version("1.2.3"), Version::new(1, 2, 3));
+    }
+
+    #[test]
+    fn test_parse_version_with_v() {
+        assert_eq!(parse_version("v1.2.3"), Version::new(1, 2, 3));
+    }
+
+    #[test]
+    fn test_parse_version_with_prerelease() {
+        assert_eq!(parse_version("1.2.3-alpha"), Version::new(1, 2, 3));
+    }
+
+    #[test]
+    fn test_parse_version_with_build() {
+        assert_eq!(parse_version("1.2.3+1"), Version::new(1, 2, 3));
+    }
+
+    #[test]
+    fn test_parse_version_two_parts() {
+        assert_eq!(parse_version("1.2"), Version::new(1, 2, 0));
+    }
+
+    #[test]
+    fn test_parse_version_one_part() {
+        assert_eq!(parse_version("1"), Version::new(1, 0, 0));
+    }
+
+    #[test]
+    fn test_parse_version_complex() {
+        assert_eq!(parse_version("v28.1.1+1"), Version::new(28, 1, 1));
+    }
+
+    #[test]
+    fn test_parse_version_beta() {
+        assert_eq!(
+            parse_version("2.0.0-beta.1+exp.sha.5114f85"),
+            Version::new(2, 0, 0)
+        );
+    }
+}

libs/cli/src/docker/compose.rs

@@ -0,0 +1,791 @@
+use indexmap::IndexMap;
+
+use super::capabilities::DockerCapabilities;
+use crate::constants::DEFAULT_POSTGRES_URI;
+
+/// Value types for our custom YAML writer.
+#[derive(Debug, Clone)]
+pub enum YamlValue {
+    String(String),
+    Dict(IndexMap<String, YamlValue>),
+    List(Vec<String>),
+}
+
+/// Convert a dictionary to a YAML string with custom formatting.
+/// This matches the Python dict_to_yaml() output exactly.
+pub fn dict_to_yaml(d: &IndexMap<String, YamlValue>, indent: usize) -> String {
+    let mut yaml_str = String::new();
+
+    for (idx, (key, value)) in d.iter().enumerate() {
+        // Extra newline for top-level keys only (after the first)
+        if idx >= 1 && indent < 2 {
+            yaml_str.push('\n');
+        }
+        let space = "    ".repeat(indent);
+        match value {
+            YamlValue::Dict(inner) => {
+                yaml_str.push_str(&format!("{space}{key}:\n"));
+                yaml_str.push_str(&dict_to_yaml(inner, indent + 1));
+            }
+            YamlValue::List(items) => {
+                yaml_str.push_str(&format!("{space}{key}:\n"));
+                for item in items {
+                    yaml_str.push_str(&format!("{space}    - {item}\n"));
+                }
+            }
+            YamlValue::String(val) => {
+                yaml_str.push_str(&format!("{space}{key}: {val}\n"));
+            }
+        }
+    }
+    yaml_str
+}
+
+/// Create debugger service config.
+pub fn debugger_compose(port: Option<u16>, base_url: Option<&str>) -> IndexMap<String, YamlValue> {
+    let port = match port {
+        Some(p) => p,
+        None => return IndexMap::new(),
+    };
+
+    let mut debugger = IndexMap::new();
+    debugger.insert(
+        "image".to_string(),
+        YamlValue::String("langchain/langgraph-debugger".to_string()),
+    );
+    debugger.insert(
+        "restart".to_string(),
+        YamlValue::String("on-failure".to_string()),
+    );
+
+    let mut depends = IndexMap::new();
+    let mut pg_condition = IndexMap::new();
+    pg_condition.insert(
+        "condition".to_string(),
+        YamlValue::String("service_healthy".to_string()),
+    );
+    depends.insert("langgraph-postgres".to_string(), YamlValue::Dict(pg_condition));
+    debugger.insert("depends_on".to_string(), YamlValue::Dict(depends));
+
+    debugger.insert(
+        "ports".to_string(),
+        YamlValue::List(vec![format!("\"{port}:3968\"")]),
+    );
+
+    if let Some(url) = base_url {
+        let mut env = IndexMap::new();
+        env.insert(
+            "VITE_STUDIO_LOCAL_GRAPH_URL".to_string(),
+            YamlValue::String(url.to_string()),
+        );
+        debugger.insert("environment".to_string(), YamlValue::Dict(env));
+    }
+
+    let mut result = IndexMap::new();
+    result.insert("langgraph-debugger".to_string(), YamlValue::Dict(debugger));
+    result
+}
+
+/// Create a docker compose file as a dictionary.
+pub fn compose_as_dict(
+    capabilities: &DockerCapabilities,
+    port: u16,
+    debugger_port: Option<u16>,
+    debugger_base_url: Option<&str>,
+    postgres_uri: Option<&str>,
+    image: Option<&str>,
+    _base_image: Option<&str>,
+    _api_version: Option<&str>,
+) -> IndexMap<String, YamlValue> {
+    let include_db = postgres_uri.is_none();
+    let postgres_uri = postgres_uri.unwrap_or(DEFAULT_POSTGRES_URI);
+
+    let mut services = IndexMap::new();
+
+    // Redis service
+    let mut redis = IndexMap::new();
+    redis.insert(
+        "image".to_string(),
+        YamlValue::String("redis:6".to_string()),
+    );
+    let mut redis_healthcheck = IndexMap::new();
+    redis_healthcheck.insert(
+        "test".to_string(),
+        YamlValue::String("redis-cli ping".to_string()),
+    );
+    redis_healthcheck.insert(
+        "interval".to_string(),
+        YamlValue::String("5s".to_string()),
+    );
+    redis_healthcheck.insert(
+        "timeout".to_string(),
+        YamlValue::String("1s".to_string()),
+    );
+    redis_healthcheck.insert(
+        "retries".to_string(),
+        YamlValue::String("5".to_string()),
+    );
+    redis.insert("healthcheck".to_string(), YamlValue::Dict(redis_healthcheck));
+    services.insert("langgraph-redis".to_string(), YamlValue::Dict(redis));
+
+    // Postgres service (if needed)
+    if include_db {
+        let mut postgres = IndexMap::new();
+        postgres.insert(
+            "image".to_string(),
+            YamlValue::String("pgvector/pgvector:pg16".to_string()),
+        );
+        postgres.insert(
+            "ports".to_string(),
+            YamlValue::List(vec!["\"5433:5432\"".to_string()]),
+        );
+
+        let mut pg_env = IndexMap::new();
+        pg_env.insert(
+            "POSTGRES_DB".to_string(),
+            YamlValue::String("postgres".to_string()),
+        );
+        pg_env.insert(
+            "POSTGRES_USER".to_string(),
+            YamlValue::String("postgres".to_string()),
+        );
+        pg_env.insert(
+            "POSTGRES_PASSWORD".to_string(),
+            YamlValue::String("postgres".to_string()),
+        );
+        postgres.insert("environment".to_string(), YamlValue::Dict(pg_env));
+
+        postgres.insert(
+            "command".to_string(),
+            YamlValue::List(vec![
+                "postgres".to_string(),
+                "-c".to_string(),
+                "shared_preload_libraries=vector".to_string(),
+            ]),
+        );
+
+        postgres.insert(
+            "volumes".to_string(),
+            YamlValue::List(vec![
+                "langgraph-data:/var/lib/postgresql/data".to_string(),
+            ]),
+        );
+
+        let mut pg_healthcheck = IndexMap::new();
+        pg_healthcheck.insert(
+            "test".to_string(),
+            YamlValue::String("pg_isready -U postgres".to_string()),
+        );
+        pg_healthcheck.insert(
+            "start_period".to_string(),
+            YamlValue::String("10s".to_string()),
+        );
+        pg_healthcheck.insert(
+            "timeout".to_string(),
+            YamlValue::String("1s".to_string()),
+        );
+        pg_healthcheck.insert(
+            "retries".to_string(),
+            YamlValue::String("5".to_string()),
+        );
+
+        if capabilities.healthcheck_start_interval {
+            pg_healthcheck.insert(
+                "interval".to_string(),
+                YamlValue::String("60s".to_string()),
+            );
+            pg_healthcheck.insert(
+                "start_interval".to_string(),
+                YamlValue::String("1s".to_string()),
+            );
+        } else {
+            pg_healthcheck.insert(
+                "interval".to_string(),
+                YamlValue::String("5s".to_string()),
+            );
+        }
+
+        postgres.insert("healthcheck".to_string(), YamlValue::Dict(pg_healthcheck));
+        services.insert("langgraph-postgres".to_string(), YamlValue::Dict(postgres));
+    }
+
+    // Debugger service (if port specified)
+    if let Some(dbg_port) = debugger_port {
+        let debugger = debugger_compose(Some(dbg_port), debugger_base_url);
+        for (k, v) in debugger {
+            services.insert(k, v);
+        }
+    }
+
+    // LangGraph API service
+    let mut api = IndexMap::new();
+    api.insert(
+        "ports".to_string(),
+        YamlValue::List(vec![format!("\"{port}:8000\"")]),
+    );
+
+    let mut api_depends = IndexMap::new();
+    let mut redis_condition = IndexMap::new();
+    redis_condition.insert(
+        "condition".to_string(),
+        YamlValue::String("service_healthy".to_string()),
+    );
+    api_depends.insert(
+        "langgraph-redis".to_string(),
+        YamlValue::Dict(redis_condition),
+    );
+    api.insert("depends_on".to_string(), YamlValue::Dict(api_depends.clone()));
+
+    let mut api_env = IndexMap::new();
+    api_env.insert(
+        "REDIS_URI".to_string(),
+        YamlValue::String("redis://langgraph-redis:6379".to_string()),
+    );
+    api_env.insert(
+        "POSTGRES_URI".to_string(),
+        YamlValue::String(postgres_uri.to_string()),
+    );
+    api.insert("environment".to_string(), YamlValue::Dict(api_env));
+
+    if let Some(img) = image {
+        api.insert(
+            "image".to_string(),
+            YamlValue::String(img.to_string()),
+        );
+    }
+
+    // Add postgres dependency for API service
+    if include_db {
+        if let YamlValue::Dict(ref mut deps) = api.get_mut("depends_on").unwrap() {
+            let mut pg_condition = IndexMap::new();
+            pg_condition.insert(
+                "condition".to_string(),
+                YamlValue::String("service_healthy".to_string()),
+            );
+            deps.insert(
+                "langgraph-postgres".to_string(),
+                YamlValue::Dict(pg_condition),
+            );
+        }
+    }
+
+    // Healthcheck for API service
+    if capabilities.healthcheck_start_interval {
+        let mut api_healthcheck = IndexMap::new();
+        api_healthcheck.insert(
+            "test".to_string(),
+            YamlValue::String("python /api/healthcheck.py".to_string()),
+        );
+        api_healthcheck.insert(
+            "interval".to_string(),
+            YamlValue::String("60s".to_string()),
+        );
+        api_healthcheck.insert(
+            "start_interval".to_string(),
+            YamlValue::String("1s".to_string()),
+        );
+        api_healthcheck.insert(
+            "start_period".to_string(),
+            YamlValue::String("10s".to_string()),
+        );
+        api.insert("healthcheck".to_string(), YamlValue::Dict(api_healthcheck));
+    }
+
+    services.insert("langgraph-api".to_string(), YamlValue::Dict(api));
+
+    // Build final compose dict
+    let mut compose_dict = IndexMap::new();
+    if include_db {
+        let mut volumes = IndexMap::new();
+        let mut vol_config = IndexMap::new();
+        vol_config.insert(
+            "driver".to_string(),
+            YamlValue::String("local".to_string()),
+        );
+        volumes.insert("langgraph-data".to_string(), YamlValue::Dict(vol_config));
+        compose_dict.insert("volumes".to_string(), YamlValue::Dict(volumes));
+    }
+    compose_dict.insert("services".to_string(), YamlValue::Dict(services));
+
+    compose_dict
+}
+
+/// Create a docker compose file as a string.
+pub fn compose(
+    capabilities: &DockerCapabilities,
+    port: u16,
+    debugger_port: Option<u16>,
+    debugger_base_url: Option<&str>,
+    postgres_uri: Option<&str>,
+    image: Option<&str>,
+    base_image: Option<&str>,
+    api_version: Option<&str>,
+) -> String {
+    let compose_dict = compose_as_dict(
+        capabilities,
+        port,
+        debugger_port,
+        debugger_base_url,
+        postgres_uri,
+        image,
+        base_image,
+        api_version,
+    );
+    dict_to_yaml(&compose_dict, 0)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::docker::capabilities::{ComposeType, Version};
+    use crate::util::clean_empty_lines;
+
+    fn default_capabilities() -> DockerCapabilities {
+        DockerCapabilities {
+            version_docker: Version::new(26, 1, 1),
+            version_compose: Version::new(2, 27, 0),
+            healthcheck_start_interval: false,
+            compose_type: ComposeType::Plugin,
+        }
+    }
+
+    #[test]
+    fn test_dict_to_yaml_simple() {
+        let mut d = IndexMap::new();
+        d.insert(
+            "key1".to_string(),
+            YamlValue::String("value1".to_string()),
+        );
+        d.insert(
+            "key2".to_string(),
+            YamlValue::String("value2".to_string()),
+        );
+        let result = dict_to_yaml(&d, 0);
+        // Top-level keys get an extra newline separator between them
+        assert_eq!(result, "key1: value1\n\nkey2: value2\n");
+    }
+
+    #[test]
+    fn test_dict_to_yaml_nested() {
+        let mut inner = IndexMap::new();
+        inner.insert(
+            "nested_key".to_string(),
+            YamlValue::String("nested_value".to_string()),
+        );
+        let mut d = IndexMap::new();
+        d.insert("outer".to_string(), YamlValue::Dict(inner));
+        let result = dict_to_yaml(&d, 0);
+        assert_eq!(result, "outer:\n    nested_key: nested_value\n");
+    }
+
+    #[test]
+    fn test_dict_to_yaml_list() {
+        let mut d = IndexMap::new();
+        d.insert(
+            "items".to_string(),
+            YamlValue::List(vec!["a".to_string(), "b".to_string()]),
+        );
+        let result = dict_to_yaml(&d, 0);
+        assert_eq!(result, "items:\n    - a\n    - b\n");
+    }
+
+    #[test]
+    fn test_compose_with_no_debugger_and_custom_db() {
+        let port = 8123;
+        let custom_postgres_uri = "custom_postgres_uri";
+        let actual = compose(
+            &default_capabilities(),
+            port,
+            None,
+            None,
+            Some(custom_postgres_uri),
+            None,
+            None,
+            None,
+        );
+        let expected = format!(
+            "services:\n\
+             \x20   langgraph-redis:\n\
+             \x20       image: redis:6\n\
+             \x20       healthcheck:\n\
+             \x20           test: redis-cli ping\n\
+             \x20           interval: 5s\n\
+             \x20           timeout: 1s\n\
+             \x20           retries: 5\n\
+             \x20   langgraph-api:\n\
+             \x20       ports:\n\
+             \x20           - \"{port}:8000\"\n\
+             \x20       depends_on:\n\
+             \x20           langgraph-redis:\n\
+             \x20               condition: service_healthy\n\
+             \x20       environment:\n\
+             \x20           REDIS_URI: redis://langgraph-redis:6379\n\
+             \x20           POSTGRES_URI: {custom_postgres_uri}"
+        );
+        assert_eq!(clean_empty_lines(&actual), expected);
+    }
+
+    #[test]
+    fn test_compose_with_no_debugger_and_custom_db_with_healthcheck() {
+        let port = 8123;
+        let custom_postgres_uri = "custom_postgres_uri";
+        let mut caps = default_capabilities();
+        caps.healthcheck_start_interval = true;
+        let actual = compose(
+            &caps,
+            port,
+            None,
+            None,
+            Some(custom_postgres_uri),
+            None,
+            None,
+            None,
+        );
+        let expected = format!(
+            "services:\n\
+             \x20   langgraph-redis:\n\
+             \x20       image: redis:6\n\
+             \x20       healthcheck:\n\
+             \x20           test: redis-cli ping\n\
+             \x20           interval: 5s\n\
+             \x20           timeout: 1s\n\
+             \x20           retries: 5\n\
+             \x20   langgraph-api:\n\
+             \x20       ports:\n\
+             \x20           - \"{port}:8000\"\n\
+             \x20       depends_on:\n\
+             \x20           langgraph-redis:\n\
+             \x20               condition: service_healthy\n\
+             \x20       environment:\n\
+             \x20           REDIS_URI: redis://langgraph-redis:6379\n\
+             \x20           POSTGRES_URI: {custom_postgres_uri}\n\
+             \x20       healthcheck:\n\
+             \x20           test: python /api/healthcheck.py\n\
+             \x20           interval: 60s\n\
+             \x20           start_interval: 1s\n\
+             \x20           start_period: 10s"
+        );
+        assert_eq!(clean_empty_lines(&actual), expected);
+    }
+
+    #[test]
+    fn test_compose_with_debugger_and_custom_db() {
+        let port = 8123;
+        let custom_postgres_uri = "custom_postgres_uri";
+        let actual = compose(
+            &default_capabilities(),
+            port,
+            None,
+            None,
+            Some(custom_postgres_uri),
+            None,
+            None,
+            None,
+        );
+        let expected = format!(
+            "services:\n\
+             \x20   langgraph-redis:\n\
+             \x20       image: redis:6\n\
+             \x20       healthcheck:\n\
+             \x20           test: redis-cli ping\n\
+             \x20           interval: 5s\n\
+             \x20           timeout: 1s\n\
+             \x20           retries: 5\n\
+             \x20   langgraph-api:\n\
+             \x20       ports:\n\
+             \x20           - \"{port}:8000\"\n\
+             \x20       depends_on:\n\
+             \x20           langgraph-redis:\n\
+             \x20               condition: service_healthy\n\
+             \x20       environment:\n\
+             \x20           REDIS_URI: redis://langgraph-redis:6379\n\
+             \x20           POSTGRES_URI: {custom_postgres_uri}"
+        );
+        assert_eq!(clean_empty_lines(&actual), expected);
+    }
+
+    #[test]
+    fn test_compose_with_debugger_and_default_db() {
+        let port = 8123;
+        let actual = compose(
+            &default_capabilities(),
+            port,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        );
+        let expected = format!(
+            "volumes:\n\
+             \x20   langgraph-data:\n\
+             \x20       driver: local\n\
+             services:\n\
+             \x20   langgraph-redis:\n\
+             \x20       image: redis:6\n\
+             \x20       healthcheck:\n\
+             \x20           test: redis-cli ping\n\
+             \x20           interval: 5s\n\
+             \x20           timeout: 1s\n\
+             \x20           retries: 5\n\
+             \x20   langgraph-postgres:\n\
+             \x20       image: pgvector/pgvector:pg16\n\
+             \x20       ports:\n\
+             \x20           - \"5433:5432\"\n\
+             \x20       environment:\n\
+             \x20           POSTGRES_DB: postgres\n\
+             \x20           POSTGRES_USER: postgres\n\
+             \x20           POSTGRES_PASSWORD: postgres\n\
+             \x20       command:\n\
+             \x20           - postgres\n\
+             \x20           - -c\n\
+             \x20           - shared_preload_libraries=vector\n\
+             \x20       volumes:\n\
+             \x20           - langgraph-data:/var/lib/postgresql/data\n\
+             \x20       healthcheck:\n\
+             \x20           test: pg_isready -U postgres\n\
+             \x20           start_period: 10s\n\
+             \x20           timeout: 1s\n\
+             \x20           retries: 5\n\
+             \x20           interval: 5s\n\
+             \x20   langgraph-api:\n\
+             \x20       ports:\n\
+             \x20           - \"{port}:8000\"\n\
+             \x20       depends_on:\n\
+             \x20           langgraph-redis:\n\
+             \x20               condition: service_healthy\n\
+             \x20           langgraph-postgres:\n\
+             \x20               condition: service_healthy\n\
+             \x20       environment:\n\
+             \x20           REDIS_URI: redis://langgraph-redis:6379\n\
+             \x20           POSTGRES_URI: {DEFAULT_POSTGRES_URI}"
+        );
+        assert_eq!(clean_empty_lines(&actual), expected);
+    }
+
+    #[test]
+    fn test_compose_with_api_version() {
+        let port = 8123;
+        let actual = compose(
+            &default_capabilities(),
+            port,
+            None,
+            None,
+            None,
+            None,
+            None,
+            Some("0.2.74"),
+        );
+        let expected = format!(
+            "volumes:\n\
+             \x20   langgraph-data:\n\
+             \x20       driver: local\n\
+             services:\n\
+             \x20   langgraph-redis:\n\
+             \x20       image: redis:6\n\
+             \x20       healthcheck:\n\
+             \x20           test: redis-cli ping\n\
+             \x20           interval: 5s\n\
+             \x20           timeout: 1s\n\
+             \x20           retries: 5\n\
+             \x20   langgraph-postgres:\n\
+             \x20       image: pgvector/pgvector:pg16\n\
+             \x20       ports:\n\
+             \x20           - \"5433:5432\"\n\
+             \x20       environment:\n\
+             \x20           POSTGRES_DB: postgres\n\
+             \x20           POSTGRES_USER: postgres\n\
+             \x20           POSTGRES_PASSWORD: postgres\n\
+             \x20       command:\n\
+             \x20           - postgres\n\
+             \x20           - -c\n\
+             \x20           - shared_preload_libraries=vector\n\
+             \x20       volumes:\n\
+             \x20           - langgraph-data:/var/lib/postgresql/data\n\
+             \x20       healthcheck:\n\
+             \x20           test: pg_isready -U postgres\n\
+             \x20           start_period: 10s\n\
+             \x20           timeout: 1s\n\
+             \x20           retries: 5\n\
+             \x20           interval: 5s\n\
+             \x20   langgraph-api:\n\
+             \x20       ports:\n\
+             \x20           - \"{port}:8000\"\n\
+             \x20       depends_on:\n\
+             \x20           langgraph-redis:\n\
+             \x20               condition: service_healthy\n\
+             \x20           langgraph-postgres:\n\
+             \x20               condition: service_healthy\n\
+             \x20       environment:\n\
+             \x20           REDIS_URI: redis://langgraph-redis:6379\n\
+             \x20           POSTGRES_URI: {DEFAULT_POSTGRES_URI}"
+        );
+        assert_eq!(clean_empty_lines(&actual), expected);
+    }
+
+    #[test]
+    fn test_compose_with_api_version_and_base_image() {
+        let port = 8123;
+        let actual = compose(
+            &default_capabilities(),
+            port,
+            None,
+            None,
+            None,
+            None,
+            Some("my-registry/custom-api"),
+            Some("1.0.0"),
+        );
+        let expected = format!(
+            "volumes:\n\
+             \x20   langgraph-data:\n\
+             \x20       driver: local\n\
+             services:\n\
+             \x20   langgraph-redis:\n\
+             \x20       image: redis:6\n\
+             \x20       healthcheck:\n\
+             \x20           test: redis-cli ping\n\
+             \x20           interval: 5s\n\
+             \x20           timeout: 1s\n\
+             \x20           retries: 5\n\
+             \x20   langgraph-postgres:\n\
+             \x20       image: pgvector/pgvector:pg16\n\
+             \x20       ports:\n\
+             \x20           - \"5433:5432\"\n\
+             \x20       environment:\n\
+             \x20           POSTGRES_DB: postgres\n\
+             \x20           POSTGRES_USER: postgres\n\
+             \x20           POSTGRES_PASSWORD: postgres\n\
+             \x20       command:\n\
+             \x20           - postgres\n\
+             \x20           - -c\n\
+             \x20           - shared_preload_libraries=vector\n\
+             \x20       volumes:\n\
+             \x20           - langgraph-data:/var/lib/postgresql/data\n\
+             \x20       healthcheck:\n\
+             \x20           test: pg_isready -U postgres\n\
+             \x20           start_period: 10s\n\
+             \x20           timeout: 1s\n\
+             \x20           retries: 5\n\
+             \x20           interval: 5s\n\
+             \x20   langgraph-api:\n\
+             \x20       ports:\n\
+             \x20           - \"{port}:8000\"\n\
+             \x20       depends_on:\n\
+             \x20           langgraph-redis:\n\
+             \x20               condition: service_healthy\n\
+             \x20           langgraph-postgres:\n\
+             \x20               condition: service_healthy\n\
+             \x20       environment:\n\
+             \x20           REDIS_URI: redis://langgraph-redis:6379\n\
+             \x20           POSTGRES_URI: {DEFAULT_POSTGRES_URI}"
+        );
+        assert_eq!(clean_empty_lines(&actual), expected);
+    }
+
+    #[test]
+    fn test_compose_with_api_version_and_custom_postgres() {
+        let port = 8123;
+        let custom_postgres_uri = "postgresql://user:pass@external-db:5432/mydb";
+        let actual = compose(
+            &default_capabilities(),
+            port,
+            None,
+            None,
+            Some(custom_postgres_uri),
+            None,
+            None,
+            Some("0.2.74"),
+        );
+        let expected = format!(
+            "services:\n\
+             \x20   langgraph-redis:\n\
+             \x20       image: redis:6\n\
+             \x20       healthcheck:\n\
+             \x20           test: redis-cli ping\n\
+             \x20           interval: 5s\n\
+             \x20           timeout: 1s\n\
+             \x20           retries: 5\n\
+             \x20   langgraph-api:\n\
+             \x20       ports:\n\
+             \x20           - \"{port}:8000\"\n\
+             \x20       depends_on:\n\
+             \x20           langgraph-redis:\n\
+             \x20               condition: service_healthy\n\
+             \x20       environment:\n\
+             \x20           REDIS_URI: redis://langgraph-redis:6379\n\
+             \x20           POSTGRES_URI: {custom_postgres_uri}"
+        );
+        assert_eq!(clean_empty_lines(&actual), expected);
+    }
+
+    #[test]
+    fn test_compose_with_api_version_and_debugger() {
+        let port = 8123;
+        let debugger_port = 8001;
+        let actual = compose(
+            &default_capabilities(),
+            port,
+            Some(debugger_port),
+            None,
+            None,
+            None,
+            None,
+            Some("0.2.74"),
+        );
+        let expected = format!(
+            "volumes:\n\
+             \x20   langgraph-data:\n\
+             \x20       driver: local\n\
+             services:\n\
+             \x20   langgraph-redis:\n\
+             \x20       image: redis:6\n\
+             \x20       healthcheck:\n\
+             \x20           test: redis-cli ping\n\
+             \x20           interval: 5s\n\
+             \x20           timeout: 1s\n\
+             \x20           retries: 5\n\
+             \x20   langgraph-postgres:\n\
+             \x20       image: pgvector/pgvector:pg16\n\
+             \x20       ports:\n\
+             \x20           - \"5433:5432\"\n\
+             \x20       environment:\n\
+             \x20           POSTGRES_DB: postgres\n\
+             \x20           POSTGRES_USER: postgres\n\
+             \x20           POSTGRES_PASSWORD: postgres\n\
+             \x20       command:\n\
+             \x20           - postgres\n\
+             \x20           - -c\n\
+             \x20           - shared_preload_libraries=vector\n\
+             \x20       volumes:\n\
+             \x20           - langgraph-data:/var/lib/postgresql/data\n\
+             \x20       healthcheck:\n\
+             \x20           test: pg_isready -U postgres\n\
+             \x20           start_period: 10s\n\
+             \x20           timeout: 1s\n\
+             \x20           retries: 5\n\
+             \x20           interval: 5s\n\
+             \x20   langgraph-debugger:\n\
+             \x20       image: langchain/langgraph-debugger\n\
+             \x20       restart: on-failure\n\
+             \x20       depends_on:\n\
+             \x20           langgraph-postgres:\n\
+             \x20               condition: service_healthy\n\
+             \x20       ports:\n\
+             \x20           - \"{debugger_port}:3968\"\n\
+             \x20   langgraph-api:\n\
+             \x20       ports:\n\
+             \x20           - \"{port}:8000\"\n\
+             \x20       depends_on:\n\
+             \x20           langgraph-redis:\n\
+             \x20               condition: service_healthy\n\
+             \x20           langgraph-postgres:\n\
+             \x20               condition: service_healthy\n\
+             \x20       environment:\n\
+             \x20           REDIS_URI: redis://langgraph-redis:6379\n\
+             \x20           POSTGRES_URI: {DEFAULT_POSTGRES_URI}"
+        );
+        assert_eq!(clean_empty_lines(&actual), expected);
+    }
+}

libs/cli/src/docker/mod.rs

@@ -0,0 +1,3 @@
+pub mod capabilities;
+pub mod compose;
+pub mod dockerfile;

libs/cli/src/exec.rs

@@ -0,0 +1,211 @@
+use std::io::{BufRead, BufReader, Write};
+use std::process::{Command, Stdio};
+
+/// Run a command synchronously, optionally piping stdin, and capturing stdout/stderr.
+///
+/// If `verbose` is true, the command is echoed to stdout before execution.
+///
+/// Returns `(Option<stdout>, Option<stderr>)` on success, or an error message on failure.
+pub fn run_command(
+    cmd: &str,
+    args: &[&str],
+    input: Option<&str>,
+    verbose: bool,
+) -> Result<(Option<String>, Option<String>), String> {
+    if verbose {
+        let cmd_str = format!("+ {} {}", cmd, args.join(" "));
+        if let Some(inp) = input {
+            let filtered: Vec<&str> = inp.lines().filter(|l| !l.is_empty()).collect();
+            println!("{} <\n{}", cmd_str, filtered.join("\n"));
+        } else {
+            println!("{cmd_str}");
+        }
+    }
+
+    let stdin_cfg = if input.is_some() {
+        Stdio::piped()
+    } else {
+        Stdio::null()
+    };
+
+    let mut child = Command::new(cmd)
+        .args(args)
+        .stdin(stdin_cfg)
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .map_err(|e| format!("Failed to execute `{cmd}`: {e}"))?;
+
+    if let Some(input_data) = input {
+        if let Some(ref mut stdin_handle) = child.stdin {
+            stdin_handle
+                .write_all(input_data.as_bytes())
+                .map_err(|e| format!("Failed to write to stdin of `{cmd}`: {e}"))?;
+        }
+        // Drop stdin to signal EOF
+        drop(child.stdin.take());
+    }
+
+    let output = child
+        .wait_with_output()
+        .map_err(|e| format!("Failed to wait for `{cmd}`: {e}"))?;
+
+    if !output.status.success() {
+        let code = output.status.code().unwrap_or(-1);
+        // 130 = SIGINT (Ctrl-C), not an error
+        if code == 130 {
+            return Ok((None, None));
+        }
+        let stdout_str = String::from_utf8_lossy(&output.stdout);
+        let stderr_str = String::from_utf8_lossy(&output.stderr);
+        return Err(format!(
+            "Command `{cmd}` exited with code {code}\nstdout: {stdout_str}\nstderr: {stderr_str}"
+        ));
+    }
+
+    let stdout = if output.stdout.is_empty() {
+        None
+    } else {
+        Some(String::from_utf8_lossy(&output.stdout).to_string())
+    };
+    let stderr = if output.stderr.is_empty() {
+        None
+    } else {
+        Some(String::from_utf8_lossy(&output.stderr).to_string())
+    };
+
+    Ok((stdout, stderr))
+}
+
+/// Run a command and stream its stdout/stderr to the parent process in real-time.
+///
+/// This is useful for long-running commands like `docker compose up` where we
+/// want to see output as it happens.
+pub fn run_command_streaming(
+    cmd: &str,
+    args: &[&str],
+    input: Option<&str>,
+    verbose: bool,
+) -> Result<(), String> {
+    if verbose {
+        let cmd_str = format!("+ {} {}", cmd, args.join(" "));
+        if let Some(inp) = input {
+            let filtered: Vec<&str> = inp.lines().filter(|l| !l.is_empty()).collect();
+            println!("{} <\n{}", cmd_str, filtered.join("\n"));
+        } else {
+            println!("{cmd_str}");
+        }
+    }
+
+    let stdin_cfg = if input.is_some() {
+        Stdio::piped()
+    } else {
+        Stdio::null()
+    };
+
+    let mut child = Command::new(cmd)
+        .args(args)
+        .stdin(stdin_cfg)
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit())
+        .spawn()
+        .map_err(|e| format!("Failed to execute `{cmd}`: {e}"))?;
+
+    if let Some(input_data) = input {
+        if let Some(ref mut stdin_handle) = child.stdin {
+            stdin_handle
+                .write_all(input_data.as_bytes())
+                .map_err(|e| format!("Failed to write to stdin of `{cmd}`: {e}"))?;
+        }
+        drop(child.stdin.take());
+    }
+
+    let status = child
+        .wait()
+        .map_err(|e| format!("Failed to wait for `{cmd}`: {e}"))?;
+
+    if !status.success() {
+        let code = status.code().unwrap_or(-1);
+        if code == 130 {
+            return Ok(());
+        }
+        return Err(format!("Command `{cmd}` exited with code {code}"));
+    }
+
+    Ok(())
+}
+
+/// Run a command, streaming stderr to the parent process, while intercepting
+/// stdout line-by-line through a callback. Each stdout line is forwarded to
+/// the parent's stdout after the callback processes it.
+pub fn run_command_streaming_with_callback<F>(
+    cmd: &str,
+    args: &[&str],
+    input: Option<&str>,
+    verbose: bool,
+    mut on_stdout: F,
+) -> Result<(), String>
+where
+    F: FnMut(&str),
+{
+    if verbose {
+        let cmd_str = format!("+ {} {}", cmd, args.join(" "));
+        if let Some(inp) = input {
+            let filtered: Vec<&str> = inp.lines().filter(|l| !l.is_empty()).collect();
+            println!("{} <\n{}", cmd_str, filtered.join("\n"));
+        } else {
+            println!("{cmd_str}");
+        }
+    }
+
+    let stdin_cfg = if input.is_some() {
+        Stdio::piped()
+    } else {
+        Stdio::null()
+    };
+
+    let mut child = Command::new(cmd)
+        .args(args)
+        .stdin(stdin_cfg)
+        .stdout(Stdio::piped())
+        .stderr(Stdio::inherit())
+        .spawn()
+        .map_err(|e| format!("Failed to execute `{cmd}`: {e}"))?;
+
+    if let Some(input_data) = input {
+        if let Some(ref mut stdin_handle) = child.stdin {
+            stdin_handle
+                .write_all(input_data.as_bytes())
+                .map_err(|e| format!("Failed to write to stdin of `{cmd}`: {e}"))?;
+        }
+        drop(child.stdin.take());
+    }
+
+    // Read stdout line by line, forward to our stdout, and call callback
+    if let Some(stdout) = child.stdout.take() {
+        let reader = BufReader::new(stdout);
+        for line in reader.lines() {
+            match line {
+                Ok(line) => {
+                    println!("{line}");
+                    on_stdout(&line);
+                }
+                Err(_) => break,
+            }
+        }
+    }
+
+    let status = child
+        .wait()
+        .map_err(|e| format!("Failed to wait for `{cmd}`: {e}"))?;
+
+    if !status.success() {
+        let code = status.code().unwrap_or(-1);
+        if code == 130 {
+            return Ok(());
+        }
+        return Err(format!("Command `{cmd}` exited with code {code}"));
+    }
+
+    Ok(())
+}

libs/cli/src/main.rs

@@ -0,0 +1,305 @@
+mod analytics;
+mod commands;
+mod config;
+mod constants;
+mod docker;
+mod exec;
+mod progress;
+mod templates;
+mod util;
+
+use clap::{Parser, Subcommand};
+
+const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+#[derive(Parser)]
+#[command(name = "langgraph", version = VERSION, about = "LangGraph CLI")]
+struct Cli {
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Launch LangGraph API server with Docker
+    Up {
+        /// Path to configuration file declaring dependencies, graphs and environment variables
+        #[arg(short, long, default_value = "langgraph.json")]
+        config: String,
+
+        /// Port to expose
+        #[arg(short, long, default_value_t = 8123)]
+        port: u16,
+
+        /// Path to docker-compose.yml file with additional services
+        #[arg(short, long)]
+        docker_compose: Option<String>,
+
+        /// Show detailed output
+        #[arg(short, long)]
+        verbose: bool,
+
+        /// Restart on file changes using docker compose watch
+        #[arg(short, long)]
+        watch: bool,
+
+        /// Recreate containers even if configuration hasn't changed
+        #[arg(long)]
+        recreate: bool,
+
+        /// Skip pulling latest images before running
+        #[arg(long)]
+        no_pull: bool,
+
+        /// Wait for services to be healthy before returning
+        #[arg(long)]
+        wait: bool,
+
+        /// Port to expose the debugger on
+        #[arg(long)]
+        debugger_port: Option<u16>,
+
+        /// Base URL for the debugger
+        #[arg(long)]
+        debugger_base_url: Option<String>,
+
+        /// Postgres connection URI
+        #[arg(long)]
+        postgres_uri: Option<String>,
+
+        /// API version of the LangGraph server
+        #[arg(long)]
+        api_version: Option<String>,
+
+        /// Pre-built image to use instead of building
+        #[arg(long)]
+        image: Option<String>,
+
+        /// Base image for the LangGraph API server
+        #[arg(long)]
+        base_image: Option<String>,
+    },
+
+    /// Build LangGraph API server Docker image
+    Build {
+        /// Path to configuration file
+        #[arg(short, long, default_value = "langgraph.json")]
+        config: String,
+
+        /// Tag for the docker image
+        #[arg(short, long)]
+        tag: String,
+
+        /// Skip pulling latest images before building
+        #[arg(long)]
+        no_pull: bool,
+
+        /// Base image for the LangGraph API server
+        #[arg(long)]
+        base_image: Option<String>,
+
+        /// API version of the LangGraph server
+        #[arg(long)]
+        api_version: Option<String>,
+
+        /// Custom install command
+        #[arg(long)]
+        install_command: Option<String>,
+
+        /// Custom build command
+        #[arg(long)]
+        build_command: Option<String>,
+
+        /// Additional arguments to pass to docker build
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+        docker_build_args: Vec<String>,
+    },
+
+    /// Generate a Dockerfile for the LangGraph API server
+    Dockerfile {
+        /// Path to save the generated Dockerfile
+        save_path: String,
+
+        /// Path to configuration file
+        #[arg(short, long, default_value = "langgraph.json")]
+        config: String,
+
+        /// Add docker-compose.yml, .env, and .dockerignore files
+        #[arg(long)]
+        add_docker_compose: bool,
+
+        /// Base image for the LangGraph API server
+        #[arg(long)]
+        base_image: Option<String>,
+
+        /// API version of the LangGraph server
+        #[arg(long)]
+        api_version: Option<String>,
+    },
+
+    /// Run LangGraph API server in development mode
+    Dev {
+        /// Network interface to bind to
+        #[arg(long, default_value = "127.0.0.1")]
+        host: String,
+
+        /// Port number
+        #[arg(long, default_value_t = 2024)]
+        port: u16,
+
+        /// Disable automatic reloading
+        #[arg(long)]
+        no_reload: bool,
+
+        /// Path to configuration file
+        #[arg(short, long, default_value = "langgraph.json")]
+        config: String,
+
+        /// Max concurrent jobs per worker
+        #[arg(long)]
+        n_jobs_per_worker: Option<u32>,
+
+        /// Skip opening browser
+        #[arg(long)]
+        no_browser: bool,
+
+        /// Enable remote debugging on specified port
+        #[arg(long)]
+        debug_port: Option<u16>,
+
+        /// Wait for debugger client to connect
+        #[arg(long)]
+        wait_for_client: bool,
+
+        /// URL of LangGraph Studio
+        #[arg(long)]
+        studio_url: Option<String>,
+
+        /// Allow synchronous I/O blocking operations
+        #[arg(long)]
+        allow_blocking: bool,
+
+        /// Expose via public tunnel
+        #[arg(long)]
+        tunnel: bool,
+
+        /// Log level for the API server
+        #[arg(long, default_value = "WARNING")]
+        server_log_level: String,
+    },
+
+    /// Create a new LangGraph project from a template
+    New {
+        /// Path to create the project
+        path: Option<String>,
+
+        /// Template to use
+        #[arg(long)]
+        template: Option<String>,
+    },
+}
+
+fn main() {
+    let cli = Cli::parse();
+
+    let result = match cli.command {
+        Commands::Up {
+            config,
+            port,
+            docker_compose,
+            verbose,
+            watch,
+            recreate,
+            no_pull,
+            wait,
+            debugger_port,
+            debugger_base_url,
+            postgres_uri,
+            api_version,
+            image,
+            base_image,
+        } => commands::up::run(
+            &config,
+            port,
+            docker_compose.as_deref(),
+            verbose,
+            watch,
+            recreate,
+            !no_pull,
+            wait,
+            debugger_port,
+            debugger_base_url.as_deref(),
+            postgres_uri.as_deref(),
+            api_version.as_deref(),
+            image.as_deref(),
+            base_image.as_deref(),
+        ),
+        Commands::Build {
+            config,
+            tag,
+            no_pull,
+            base_image,
+            api_version,
+            install_command,
+            build_command,
+            docker_build_args,
+        } => commands::build_cmd::run(
+            &config,
+            &tag,
+            !no_pull,
+            base_image.as_deref(),
+            api_version.as_deref(),
+            install_command.as_deref(),
+            build_command.as_deref(),
+            &docker_build_args,
+        ),
+        Commands::Dockerfile {
+            save_path,
+            config,
+            add_docker_compose,
+            base_image,
+            api_version,
+        } => commands::dockerfile::run(
+            &save_path,
+            &config,
+            add_docker_compose,
+            base_image.as_deref(),
+            api_version.as_deref(),
+        ),
+        Commands::Dev {
+            host,
+            port,
+            no_reload,
+            config,
+            n_jobs_per_worker,
+            no_browser,
+            debug_port,
+            wait_for_client,
+            studio_url,
+            allow_blocking,
+            tunnel,
+            server_log_level,
+        } => commands::dev::run(
+            &host,
+            port,
+            no_reload,
+            &config,
+            n_jobs_per_worker,
+            no_browser,
+            debug_port,
+            wait_for_client,
+            studio_url.as_deref(),
+            allow_blocking,
+            tunnel,
+            &server_log_level,
+        ),
+        Commands::New { path, template } => {
+            commands::new::run(path.as_deref(), template.as_deref())
+        }
+    };
+
+    if let Err(e) = result {
+        eprintln!("Error: {e}");
+        std::process::exit(1);
+    }
+}

libs/cli/src/progress.rs

@@ -0,0 +1,43 @@
+use indicatif::{ProgressBar, ProgressStyle};
+
+/// Terminal spinner using indicatif.
+///
+/// Wraps an indicatif spinner that displays an animated progress indicator
+/// with a configurable message.
+pub struct Progress {
+    spinner: ProgressBar,
+}
+
+impl Progress {
+    /// Create a new spinner with the given initial message.
+    pub fn new(message: &str) -> Self {
+        let spinner = ProgressBar::new_spinner();
+        spinner.set_style(
+            ProgressStyle::default_spinner()
+                .tick_strings(&["|", "/", "-", "\\", ""])
+                .template("{spinner} {msg}")
+                .unwrap_or_else(|_| ProgressStyle::default_spinner()),
+        );
+        spinner.set_message(message.to_string());
+        spinner.enable_steady_tick(std::time::Duration::from_millis(100));
+        Self { spinner }
+    }
+
+    /// Update the spinner message.
+    ///
+    /// If the message is empty, the spinner is effectively hidden but still running.
+    pub fn set_message(&self, msg: &str) {
+        self.spinner.set_message(msg.to_string());
+    }
+
+    /// Stop the spinner and clear it from the terminal.
+    pub fn finish(&self) {
+        self.spinner.finish_and_clear();
+    }
+}
+
+impl Drop for Progress {
+    fn drop(&mut self) {
+        self.spinner.finish_and_clear();
+    }
+}

libs/cli/src/templates.rs

@@ -0,0 +1,257 @@
+use std::collections::HashMap;
+use std::io::{Cursor, Read};
+use std::path::Path;
+
+use console::style;
+use dialoguer::{Input, Select};
+
+/// A project template definition.
+pub struct Template {
+    pub name: &'static str,
+    pub description: &'static str,
+    pub python: &'static str,
+    pub js: &'static str,
+}
+
+/// All available project templates.
+pub const TEMPLATES: &[Template] = &[
+    Template {
+        name: "New LangGraph Project",
+        description: "A simple, minimal chatbot with memory.",
+        python: "https://github.com/langchain-ai/new-langgraph-project/archive/refs/heads/main.zip",
+        js: "https://github.com/langchain-ai/new-langgraphjs-project/archive/refs/heads/main.zip",
+    },
+    Template {
+        name: "ReAct Agent",
+        description: "A simple agent that can be flexibly extended to many tools.",
+        python: "https://github.com/langchain-ai/react-agent/archive/refs/heads/main.zip",
+        js: "https://github.com/langchain-ai/react-agent-js/archive/refs/heads/main.zip",
+    },
+    Template {
+        name: "Memory Agent",
+        description: "A ReAct-style agent with an additional tool to store memories for use across conversational threads.",
+        python: "https://github.com/langchain-ai/memory-agent/archive/refs/heads/main.zip",
+        js: "https://github.com/langchain-ai/memory-agent-js/archive/refs/heads/main.zip",
+    },
+    Template {
+        name: "Retrieval Agent",
+        description: "An agent that includes a retrieval-based question-answering system.",
+        python: "https://github.com/langchain-ai/retrieval-agent-template/archive/refs/heads/main.zip",
+        js: "https://github.com/langchain-ai/retrieval-agent-template-js/archive/refs/heads/main.zip",
+    },
+    Template {
+        name: "Data-enrichment Agent",
+        description: "An agent that performs web searches and organizes its findings into a structured format.",
+        python: "https://github.com/langchain-ai/data-enrichment/archive/refs/heads/main.zip",
+        js: "https://github.com/langchain-ai/data-enrichment-js/archive/refs/heads/main.zip",
+    },
+];
+
+/// Mapping from template ID (e.g., "react-agent-python") to (template index, language, url).
+pub fn build_template_id_map() -> HashMap<String, (usize, &'static str, &'static str)> {
+    let mut map = HashMap::new();
+    for (idx, tmpl) in TEMPLATES.iter().enumerate() {
+        let base = tmpl.name.to_lowercase().replace(' ', "-");
+        map.insert(
+            format!("{base}-python"),
+            (idx, "python", tmpl.python),
+        );
+        map.insert(format!("{base}-js"), (idx, "js", tmpl.js));
+    }
+    map
+}
+
+/// Get a sorted list of all valid template IDs.
+pub fn template_ids() -> Vec<String> {
+    let map = build_template_id_map();
+    let mut ids: Vec<String> = map.keys().cloned().collect();
+    ids.sort();
+    ids
+}
+
+/// Interactively choose a template. Returns the download URL.
+fn choose_template() -> Result<String, String> {
+    eprintln!("{}", style("Please select a template:").bold().yellow());
+    let items: Vec<String> = TEMPLATES
+        .iter()
+        .map(|t| format!("{} - {}", t.name, t.description))
+        .collect();
+
+    let selection = Select::new()
+        .with_prompt("Select a template")
+        .items(&items)
+        .default(0)
+        .interact()
+        .map_err(|e| format!("Template selection failed: {e}"))?;
+
+    let tmpl = &TEMPLATES[selection];
+    eprintln!(
+        "\n{}",
+        style(format!("You selected: {} - {}", tmpl.name, tmpl.description)).green()
+    );
+
+    let lang_items = vec!["Python", "JS/TS"];
+    let lang_choice = Select::new()
+        .with_prompt("Choose language")
+        .items(&lang_items)
+        .default(0)
+        .interact()
+        .map_err(|e| format!("Language selection failed: {e}"))?;
+
+    let url = if lang_choice == 0 {
+        tmpl.python
+    } else {
+        tmpl.js
+    };
+    Ok(url.to_string())
+}
+
+/// Download a zip archive from `url` and extract to `path`.
+fn download_repo(url: &str, path: &str) -> Result<(), String> {
+    eprintln!(
+        "{}",
+        style("Downloading repository as a ZIP archive...").yellow()
+    );
+    eprintln!("{}", style(format!("URL: {url}")).yellow());
+
+    // Use blocking reqwest to download
+    let client = reqwest::blocking::Client::builder()
+        .timeout(std::time::Duration::from_secs(120))
+        .build()
+        .map_err(|e| format!("Failed to create HTTP client: {e}"))?;
+
+    let response = client
+        .get(url)
+        .send()
+        .map_err(|e| format!("Failed to download repository: {e}"))?;
+
+    if !response.status().is_success() {
+        return Err(format!(
+            "Failed to download repository. HTTP status: {}",
+            response.status()
+        ));
+    }
+
+    let bytes = response
+        .bytes()
+        .map_err(|e| format!("Failed to read response body: {e}"))?;
+
+    let target_path = Path::new(path);
+    if !target_path.exists() {
+        std::fs::create_dir_all(target_path)
+            .map_err(|e| format!("Failed to create directory {path}: {e}"))?;
+    }
+
+    let cursor = Cursor::new(bytes);
+    let mut archive =
+        zip::ZipArchive::new(cursor).map_err(|e| format!("Failed to open ZIP archive: {e}"))?;
+
+    // Extract all files
+    for i in 0..archive.len() {
+        let mut file = archive
+            .by_index(i)
+            .map_err(|e| format!("Failed to read ZIP entry: {e}"))?;
+        let name = file.name().to_string();
+
+        // Strip the top-level directory (e.g., "repo-main/")
+        let stripped = match name.split_once('/') {
+            Some((_, rest)) if !rest.is_empty() => rest.to_string(),
+            _ => continue, // Skip the top-level directory entry itself
+        };
+
+        let out_path = target_path.join(&stripped);
+
+        if file.is_dir() {
+            std::fs::create_dir_all(&out_path)
+                .map_err(|e| format!("Failed to create directory {}: {e}", out_path.display()))?;
+        } else {
+            if let Some(parent) = out_path.parent() {
+                std::fs::create_dir_all(parent).map_err(|e| {
+                    format!("Failed to create directory {}: {e}", parent.display())
+                })?;
+            }
+            let mut buf = Vec::new();
+            file.read_to_end(&mut buf)
+                .map_err(|e| format!("Failed to read file from ZIP: {e}"))?;
+            std::fs::write(&out_path, &buf)
+                .map_err(|e| format!("Failed to write {}: {e}", out_path.display()))?;
+        }
+    }
+
+    eprintln!(
+        "{}",
+        style(format!("Downloaded and extracted repository to {path}")).green()
+    );
+
+    Ok(())
+}
+
+/// Create a new LangGraph project at the specified path using the chosen template.
+///
+/// If `path` is None, the user is prompted interactively.
+/// If `template` is None, the user picks from an interactive menu.
+pub fn create_new(path: Option<&str>, template: Option<&str>) -> Result<(), String> {
+    // Prompt for path if not provided
+    let path = match path {
+        Some(p) => p.to_string(),
+        None => {
+            let input: String = Input::new()
+                .with_prompt("Please specify the path to create the application")
+                .default(".".to_string())
+                .interact_text()
+                .map_err(|e| format!("Input failed: {e}"))?;
+            input
+        }
+    };
+
+    let abs_path = std::path::Path::new(&path)
+        .canonicalize()
+        .unwrap_or_else(|_| std::path::PathBuf::from(&path));
+    let abs_path_str = abs_path.to_string_lossy().to_string();
+
+    // If the path doesn't exist yet, that's fine. But if it exists and is non-empty, abort.
+    if abs_path.exists() {
+        let entries = std::fs::read_dir(&abs_path)
+            .map_err(|e| format!("Could not read directory {abs_path_str}: {e}"))?;
+        if entries.count() > 0 {
+            return Err(
+                "The specified directory already exists and is not empty. \
+                 Aborting to prevent overwriting files."
+                    .to_string(),
+            );
+        }
+    }
+
+    // Get template URL either from command-line argument or through interactive selection
+    let template_url = if let Some(tmpl_id) = template {
+        let id_map = build_template_id_map();
+        if let Some((_idx, _lang, url)) = id_map.get(tmpl_id) {
+            url.to_string()
+        } else {
+            let ids = template_ids();
+            let mut options = String::new();
+            for id in &ids {
+                let (_idx, _lang, _url) = id_map.get(id.as_str()).unwrap();
+                let tmpl = &TEMPLATES[*_idx];
+                options.push_str(&format!("- {id}: {}\n", tmpl.description));
+            }
+            return Err(format!(
+                "Template '{tmpl_id}' not found.\n\
+                 Please select from the available options:\n{options}"
+            ));
+        }
+    } else {
+        choose_template()?
+    };
+
+    // Download and extract the template
+    download_repo(&template_url, &abs_path_str)?;
+
+    eprintln!(
+        "{}",
+        style(format!("New project created at {abs_path_str}"))
+            .green()
+            .bold()
+    );
+    Ok(())
+}

libs/cli/src/util.rs

@@ -0,0 +1,57 @@
+use console::style;
+
+/// Remove empty lines from a string.
+pub fn clean_empty_lines(input: &str) -> String {
+    input
+        .lines()
+        .filter(|line| !line.is_empty())
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+/// Show warning if image_distro is not set to 'wolfi'.
+pub fn warn_non_wolfi_distro(config: &serde_json::Value) {
+    let image_distro = config
+        .get("image_distro")
+        .and_then(|v| v.as_str())
+        .unwrap_or("debian");
+
+    if image_distro != "wolfi" {
+        eprintln!(
+            "{}",
+            style(
+                "Warning: Security Recommendation: Consider switching to Wolfi Linux for enhanced security."
+            )
+            .yellow()
+            .bold()
+        );
+        eprintln!(
+            "{}",
+            style(
+                "   Wolfi is a security-oriented, minimal Linux distribution designed for containers."
+            )
+            .yellow()
+        );
+        eprintln!(
+            "{}",
+            style(
+                "   To switch, add '\"image_distro\": \"wolfi\"' to your langgraph.json config file."
+            )
+            .yellow()
+        );
+        eprintln!();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_clean_empty_lines() {
+        assert_eq!(clean_empty_lines("line1\n\nline2\n\nline3"), "line1\nline2\nline3");
+        assert_eq!(clean_empty_lines("line1\nline2\nline3"), "line1\nline2\nline3");
+        assert_eq!(clean_empty_lines("\n\n\n"), "");
+        assert_eq!(clean_empty_lines(""), "");
+    }
+}

libs/cli/tests/unit_tests/test_config.py

@@ -120,14 +120,14 @@ def test_validate_config():
         validate_config({"python_version": "3.10"})
     assert "Minimum required version" in str(exc_info.value)
 
-    config = validate_config(
-        {
-            "python_version": "3.11-bullseye",
-            "dependencies": ["."],
-            "graphs": {"agent": "./agent.py:graph"},
-        }
-    )
-    assert config["python_version"] == "3.11-bullseye"
+    with pytest.raises(click.UsageError, match="Bullseye images were deprecated"):
+        validate_config(
+            {
+                "python_version": "3.11-bullseye",
+                "dependencies": ["."],
+                "graphs": {"agent": "./agent.py:graph"},
+            }
+        )
 
     config = validate_config(
         {
@@ -181,6 +181,17 @@ def test_validate_config_image_distro():
     )
     assert config["image_distro"] == "debian"
 
+    # Bullseye should raise deprecation error
+    with pytest.raises(click.UsageError, match="Bullseye images were deprecated"):
+        validate_config(
+            {
+                "python_version": "3.11",
+                "dependencies": ["."],
+                "graphs": {"agent": "./agent.py:graph"},
+                "image_distro": "bullseye",
+            }
+        )
+
     # Invalid image_distro values should raise error
     with pytest.raises(click.UsageError) as exc_info:
         validate_config(

libs/cli/uv.lock

@@ -385,67 +385,62 @@ wheels = [
 
 [[package]]
 name = "cryptography"
-version = "46.0.3"
+version = "46.0.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
     { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/9f/33/c00162f49c0e2fe8064a62cb92b93e50c74a72bc370ab92f86112b33ff62/cryptography-46.0.3.tar.gz", hash = "sha256:a8b17438104fed022ce745b362294d9ce35b4c2e45c1d958ad4a4b019285f4a1", size = 749258, upload-time = "2025-10-15T23:18:31.74Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/60/04/ee2a9e8542e4fa2773b81771ff8349ff19cdd56b7258a0cc442639052edb/cryptography-46.0.5.tar.gz", hash = "sha256:abace499247268e3757271b2f1e244b36b06f8515cf27c4d49468fc9eb16e93d", size = 750064, upload-time = "2026-02-10T19:18:38.255Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1d/42/9c391dd801d6cf0d561b5890549d4b27bafcc53b39c31a817e69d87c625b/cryptography-46.0.3-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:109d4ddfadf17e8e7779c39f9b18111a09efb969a301a31e987416a0191ed93a", size = 7225004, upload-time = "2025-10-15T23:16:52.239Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/67/38769ca6b65f07461eb200e85fc1639b438bdc667be02cf7f2cd6a64601c/cryptography-46.0.3-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:09859af8466b69bc3c27bdf4f5d84a665e0f7ab5088412e9e2ec49758eca5cbc", size = 4296667, upload-time = "2025-10-15T23:16:54.369Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/49/498c86566a1d80e978b42f0d702795f69887005548c041636df6ae1ca64c/cryptography-46.0.3-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:01ca9ff2885f3acc98c29f1860552e37f6d7c7d013d7334ff2a9de43a449315d", size = 4450807, upload-time = "2025-10-15T23:16:56.414Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/0a/863a3604112174c8624a2ac3c038662d9e59970c7f926acdcfaed8d61142/cryptography-46.0.3-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:6eae65d4c3d33da080cff9c4ab1f711b15c1d9760809dad6ea763f3812d254cb", size = 4299615, upload-time = "2025-10-15T23:16:58.442Z" },
-    { url = "https://files.pythonhosted.org/packages/64/02/b73a533f6b64a69f3cd3872acb6ebc12aef924d8d103133bb3ea750dc703/cryptography-46.0.3-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5bf0ed4490068a2e72ac03d786693adeb909981cc596425d09032d372bcc849", size = 4016800, upload-time = "2025-10-15T23:17:00.378Z" },
-    { url = "https://files.pythonhosted.org/packages/25/d5/16e41afbfa450cde85a3b7ec599bebefaef16b5c6ba4ec49a3532336ed72/cryptography-46.0.3-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:5ecfccd2329e37e9b7112a888e76d9feca2347f12f37918facbb893d7bb88ee8", size = 4984707, upload-time = "2025-10-15T23:17:01.98Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/56/e7e69b427c3878352c2fb9b450bd0e19ed552753491d39d7d0a2f5226d41/cryptography-46.0.3-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:a2c0cd47381a3229c403062f764160d57d4d175e022c1df84e168c6251a22eec", size = 4482541, upload-time = "2025-10-15T23:17:04.078Z" },
-    { url = "https://files.pythonhosted.org/packages/78/f6/50736d40d97e8483172f1bb6e698895b92a223dba513b0ca6f06b2365339/cryptography-46.0.3-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:549e234ff32571b1f4076ac269fcce7a808d3bf98b76c8dd560e42dbc66d7d91", size = 4299464, upload-time = "2025-10-15T23:17:05.483Z" },
-    { url = "https://files.pythonhosted.org/packages/00/de/d8e26b1a855f19d9994a19c702fa2e93b0456beccbcfe437eda00e0701f2/cryptography-46.0.3-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:c0a7bb1a68a5d3471880e264621346c48665b3bf1c3759d682fc0864c540bd9e", size = 4950838, upload-time = "2025-10-15T23:17:07.425Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/29/798fc4ec461a1c9e9f735f2fc58741b0daae30688f41b2497dcbc9ed1355/cryptography-46.0.3-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:10b01676fc208c3e6feeb25a8b83d81767e8059e1fe86e1dc62d10a3018fa926", size = 4481596, upload-time = "2025-10-15T23:17:09.343Z" },
-    { url = "https://files.pythonhosted.org/packages/15/8d/03cd48b20a573adfff7652b76271078e3045b9f49387920e7f1f631d125e/cryptography-46.0.3-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0abf1ffd6e57c67e92af68330d05760b7b7efb243aab8377e583284dbab72c71", size = 4426782, upload-time = "2025-10-15T23:17:11.22Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/b1/ebacbfe53317d55cf33165bda24c86523497a6881f339f9aae5c2e13e57b/cryptography-46.0.3-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a04bee9ab6a4da801eb9b51f1b708a1b5b5c9eb48c03f74198464c66f0d344ac", size = 4698381, upload-time = "2025-10-15T23:17:12.829Z" },
-    { url = "https://files.pythonhosted.org/packages/96/92/8a6a9525893325fc057a01f654d7efc2c64b9de90413adcf605a85744ff4/cryptography-46.0.3-cp311-abi3-win32.whl", hash = "sha256:f260d0d41e9b4da1ed1e0f1ce571f97fe370b152ab18778e9e8f67d6af432018", size = 3055988, upload-time = "2025-10-15T23:17:14.65Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/bf/80fbf45253ea585a1e492a6a17efcb93467701fa79e71550a430c5e60df0/cryptography-46.0.3-cp311-abi3-win_amd64.whl", hash = "sha256:a9a3008438615669153eb86b26b61e09993921ebdd75385ddd748702c5adfddb", size = 3514451, upload-time = "2025-10-15T23:17:16.142Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/af/9b302da4c87b0beb9db4e756386a7c6c5b8003cd0e742277888d352ae91d/cryptography-46.0.3-cp311-abi3-win_arm64.whl", hash = "sha256:5d7f93296ee28f68447397bf5198428c9aeeab45705a55d53a6343455dcb2c3c", size = 2928007, upload-time = "2025-10-15T23:17:18.04Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/e2/a510aa736755bffa9d2f75029c229111a1d02f8ecd5de03078f4c18d91a3/cryptography-46.0.3-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:00a5e7e87938e5ff9ff5447ab086a5706a957137e6e433841e9d24f38a065217", size = 7158012, upload-time = "2025-10-15T23:17:19.982Z" },
-    { url = "https://files.pythonhosted.org/packages/73/dc/9aa866fbdbb95b02e7f9d086f1fccfeebf8953509b87e3f28fff927ff8a0/cryptography-46.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c8daeb2d2174beb4575b77482320303f3d39b8e81153da4f0fb08eb5fe86a6c5", size = 4288728, upload-time = "2025-10-15T23:17:21.527Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/fd/bc1daf8230eaa075184cbbf5f8cd00ba9db4fd32d63fb83da4671b72ed8a/cryptography-46.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:39b6755623145ad5eff1dab323f4eae2a32a77a7abef2c5089a04a3d04366715", size = 4435078, upload-time = "2025-10-15T23:17:23.042Z" },
-    { url = "https://files.pythonhosted.org/packages/82/98/d3bd5407ce4c60017f8ff9e63ffee4200ab3e23fe05b765cab805a7db008/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:db391fa7c66df6762ee3f00c95a89e6d428f4d60e7abc8328f4fe155b5ac6e54", size = 4293460, upload-time = "2025-10-15T23:17:24.885Z" },
-    { url = "https://files.pythonhosted.org/packages/26/e9/e23e7900983c2b8af7a08098db406cf989d7f09caea7897e347598d4cd5b/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:78a97cf6a8839a48c49271cdcbd5cf37ca2c1d6b7fdd86cc864f302b5e9bf459", size = 3995237, upload-time = "2025-10-15T23:17:26.449Z" },
-    { url = "https://files.pythonhosted.org/packages/91/15/af68c509d4a138cfe299d0d7ddb14afba15233223ebd933b4bbdbc7155d3/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:dfb781ff7eaa91a6f7fd41776ec37c5853c795d3b358d4896fdbb5df168af422", size = 4967344, upload-time = "2025-10-15T23:17:28.06Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/e3/8643d077c53868b681af077edf6b3cb58288b5423610f21c62aadcbe99f4/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:6f61efb26e76c45c4a227835ddeae96d83624fb0d29eb5df5b96e14ed1a0afb7", size = 4466564, upload-time = "2025-10-15T23:17:29.665Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/43/c1e8726fa59c236ff477ff2b5dc071e54b21e5a1e51aa2cee1676f1c986f/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:23b1a8f26e43f47ceb6d6a43115f33a5a37d57df4ea0ca295b780ae8546e8044", size = 4292415, upload-time = "2025-10-15T23:17:31.686Z" },
-    { url = "https://files.pythonhosted.org/packages/42/f9/2f8fefdb1aee8a8e3256a0568cffc4e6d517b256a2fe97a029b3f1b9fe7e/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:b419ae593c86b87014b9be7396b385491ad7f320bde96826d0dd174459e54665", size = 4931457, upload-time = "2025-10-15T23:17:33.478Z" },
-    { url = "https://files.pythonhosted.org/packages/79/30/9b54127a9a778ccd6d27c3da7563e9f2d341826075ceab89ae3b41bf5be2/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:50fc3343ac490c6b08c0cf0d704e881d0d660be923fd3076db3e932007e726e3", size = 4466074, upload-time = "2025-10-15T23:17:35.158Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/68/b4f4a10928e26c941b1b6a179143af9f4d27d88fe84a6a3c53592d2e76bf/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:22d7e97932f511d6b0b04f2bfd818d73dcd5928db509460aaf48384778eb6d20", size = 4420569, upload-time = "2025-10-15T23:17:37.188Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/49/3746dab4c0d1979888f125226357d3262a6dd40e114ac29e3d2abdf1ec55/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d55f3dffadd674514ad19451161118fd010988540cee43d8bc20675e775925de", size = 4681941, upload-time = "2025-10-15T23:17:39.236Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/30/27654c1dbaf7e4a3531fa1fc77986d04aefa4d6d78259a62c9dc13d7ad36/cryptography-46.0.3-cp314-cp314t-win32.whl", hash = "sha256:8a6e050cb6164d3f830453754094c086ff2d0b2f3a897a1d9820f6139a1f0914", size = 3022339, upload-time = "2025-10-15T23:17:40.888Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/30/640f34ccd4d2a1bc88367b54b926b781b5a018d65f404d409aba76a84b1c/cryptography-46.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:760f83faa07f8b64e9c33fc963d790a2edb24efb479e3520c14a45741cd9b2db", size = 3494315, upload-time = "2025-10-15T23:17:42.769Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/8b/88cc7e3bd0a8e7b861f26981f7b820e1f46aa9d26cc482d0feba0ecb4919/cryptography-46.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:516ea134e703e9fe26bcd1277a4b59ad30586ea90c365a87781d7887a646fe21", size = 2919331, upload-time = "2025-10-15T23:17:44.468Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/23/45fe7f376a7df8daf6da3556603b36f53475a99ce4faacb6ba2cf3d82021/cryptography-46.0.3-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:cb3d760a6117f621261d662bccc8ef5bc32ca673e037c83fbe565324f5c46936", size = 7218248, upload-time = "2025-10-15T23:17:46.294Z" },
-    { url = "https://files.pythonhosted.org/packages/27/32/b68d27471372737054cbd34c84981f9edbc24fe67ca225d389799614e27f/cryptography-46.0.3-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4b7387121ac7d15e550f5cb4a43aef2559ed759c35df7336c402bb8275ac9683", size = 4294089, upload-time = "2025-10-15T23:17:48.269Z" },
-    { url = "https://files.pythonhosted.org/packages/26/42/fa8389d4478368743e24e61eea78846a0006caffaf72ea24a15159215a14/cryptography-46.0.3-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:15ab9b093e8f09daab0f2159bb7e47532596075139dd74365da52ecc9cb46c5d", size = 4440029, upload-time = "2025-10-15T23:17:49.837Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/eb/f483db0ec5ac040824f269e93dd2bd8a21ecd1027e77ad7bdf6914f2fd80/cryptography-46.0.3-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:46acf53b40ea38f9c6c229599a4a13f0d46a6c3fa9ef19fc1a124d62e338dfa0", size = 4297222, upload-time = "2025-10-15T23:17:51.357Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/cf/da9502c4e1912cb1da3807ea3618a6829bee8207456fbbeebc361ec38ba3/cryptography-46.0.3-cp38-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:10ca84c4668d066a9878890047f03546f3ae0a6b8b39b697457b7757aaf18dbc", size = 4012280, upload-time = "2025-10-15T23:17:52.964Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/8f/9adb86b93330e0df8b3dcf03eae67c33ba89958fc2e03862ef1ac2b42465/cryptography-46.0.3-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:36e627112085bb3b81b19fed209c05ce2a52ee8b15d161b7c643a7d5a88491f3", size = 4978958, upload-time = "2025-10-15T23:17:54.965Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/a0/5fa77988289c34bdb9f913f5606ecc9ada1adb5ae870bd0d1054a7021cc4/cryptography-46.0.3-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:1000713389b75c449a6e979ffc7dcc8ac90b437048766cef052d4d30b8220971", size = 4473714, upload-time = "2025-10-15T23:17:56.754Z" },
-    { url = "https://files.pythonhosted.org/packages/14/e5/fc82d72a58d41c393697aa18c9abe5ae1214ff6f2a5c18ac470f92777895/cryptography-46.0.3-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:b02cf04496f6576afffef5ddd04a0cb7d49cf6be16a9059d793a30b035f6b6ac", size = 4296970, upload-time = "2025-10-15T23:17:58.588Z" },
-    { url = "https://files.pythonhosted.org/packages/78/06/5663ed35438d0b09056973994f1aec467492b33bd31da36e468b01ec1097/cryptography-46.0.3-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:71e842ec9bc7abf543b47cf86b9a743baa95f4677d22baa4c7d5c69e49e9bc04", size = 4940236, upload-time = "2025-10-15T23:18:00.897Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/59/873633f3f2dcd8a053b8dd1d38f783043b5fce589c0f6988bf55ef57e43e/cryptography-46.0.3-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:402b58fc32614f00980b66d6e56a5b4118e6cb362ae8f3fda141ba4689bd4506", size = 4472642, upload-time = "2025-10-15T23:18:02.749Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/39/8e71f3930e40f6877737d6f69248cf74d4e34b886a3967d32f919cc50d3b/cryptography-46.0.3-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ef639cb3372f69ec44915fafcd6698b6cc78fbe0c2ea41be867f6ed612811963", size = 4423126, upload-time = "2025-10-15T23:18:04.85Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/c7/f65027c2810e14c3e7268353b1681932b87e5a48e65505d8cc17c99e36ae/cryptography-46.0.3-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3b51b8ca4f1c6453d8829e1eb7299499ca7f313900dd4d89a24b8b87c0a780d4", size = 4686573, upload-time = "2025-10-15T23:18:06.908Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/6e/1c8331ddf91ca4730ab3086a0f1be19c65510a33b5a441cb334e7a2d2560/cryptography-46.0.3-cp38-abi3-win32.whl", hash = "sha256:6276eb85ef938dc035d59b87c8a7dc559a232f954962520137529d77b18ff1df", size = 3036695, upload-time = "2025-10-15T23:18:08.672Z" },
-    { url = "https://files.pythonhosted.org/packages/90/45/b0d691df20633eff80955a0fc7695ff9051ffce8b69741444bd9ed7bd0db/cryptography-46.0.3-cp38-abi3-win_amd64.whl", hash = "sha256:416260257577718c05135c55958b674000baef9a1c7d9e8f306ec60d71db850f", size = 3501720, upload-time = "2025-10-15T23:18:10.632Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/cb/2da4cc83f5edb9c3257d09e1e7ab7b23f049c7962cae8d842bbef0a9cec9/cryptography-46.0.3-cp38-abi3-win_arm64.whl", hash = "sha256:d89c3468de4cdc4f08a57e214384d0471911a3830fcdaf7a8cc587e42a866372", size = 2918740, upload-time = "2025-10-15T23:18:12.277Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/cd/1a8633802d766a0fa46f382a77e096d7e209e0817892929655fe0586ae32/cryptography-46.0.3-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a23582810fedb8c0bc47524558fb6c56aac3fc252cb306072fd2815da2a47c32", size = 3689163, upload-time = "2025-10-15T23:18:13.821Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/59/6b26512964ace6480c3e54681a9859c974172fb141c38df11eadd8416947/cryptography-46.0.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:e7aec276d68421f9574040c26e2a7c3771060bc0cff408bae1dcb19d3ab1e63c", size = 3429474, upload-time = "2025-10-15T23:18:15.477Z" },
-    { url = "https://files.pythonhosted.org/packages/06/8a/e60e46adab4362a682cf142c7dcb5bf79b782ab2199b0dcb81f55970807f/cryptography-46.0.3-pp311-pypy311_pp73-macosx_10_9_x86_64.whl", hash = "sha256:7ce938a99998ed3c8aa7e7272dca1a610401ede816d36d0693907d863b10d9ea", size = 3698132, upload-time = "2025-10-15T23:18:17.056Z" },
-    { url = "https://files.pythonhosted.org/packages/da/38/f59940ec4ee91e93d3311f7532671a5cef5570eb04a144bf203b58552d11/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:191bb60a7be5e6f54e30ba16fdfae78ad3a342a0599eb4193ba88e3f3d6e185b", size = 4243992, upload-time = "2025-10-15T23:18:18.695Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/0c/35b3d92ddebfdfda76bb485738306545817253d0a3ded0bfe80ef8e67aa5/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:c70cc23f12726be8f8bc72e41d5065d77e4515efae3690326764ea1b07845cfb", size = 4409944, upload-time = "2025-10-15T23:18:20.597Z" },
-    { url = "https://files.pythonhosted.org/packages/99/55/181022996c4063fc0e7666a47049a1ca705abb9c8a13830f074edb347495/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:9394673a9f4de09e28b5356e7fff97d778f8abad85c9d5ac4a4b7e25a0de7717", size = 4242957, upload-time = "2025-10-15T23:18:22.18Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/af/72cd6ef29f9c5f731251acadaeb821559fe25f10852f44a63374c9ca08c1/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:94cd0549accc38d1494e1f8de71eca837d0509d0d44bf11d158524b0e12cebf9", size = 4409447, upload-time = "2025-10-15T23:18:24.209Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/c3/e90f4a4feae6410f914f8ebac129b9ae7a8c92eb60a638012dde42030a9d/cryptography-46.0.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:6b5063083824e5509fdba180721d55909ffacccc8adbec85268b48439423d78c", size = 3438528, upload-time = "2025-10-15T23:18:26.227Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/81/b0bb27f2ba931a65409c6b8a8b358a7f03c0e46eceacddff55f7c84b1f3b/cryptography-46.0.5-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:351695ada9ea9618b3500b490ad54c739860883df6c1f555e088eaf25b1bbaad", size = 7176289, upload-time = "2026-02-10T19:17:08.274Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/9e/6b4397a3e3d15123de3b1806ef342522393d50736c13b20ec4c9ea6693a6/cryptography-46.0.5-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c18ff11e86df2e28854939acde2d003f7984f721eba450b56a200ad90eeb0e6b", size = 4275637, upload-time = "2026-02-10T19:17:10.53Z" },
+    { url = "https://files.pythonhosted.org/packages/63/e7/471ab61099a3920b0c77852ea3f0ea611c9702f651600397ac567848b897/cryptography-46.0.5-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4d7e3d356b8cd4ea5aff04f129d5f66ebdc7b6f8eae802b93739ed520c47c79b", size = 4424742, upload-time = "2026-02-10T19:17:12.388Z" },
+    { url = "https://files.pythonhosted.org/packages/37/53/a18500f270342d66bf7e4d9f091114e31e5ee9e7375a5aba2e85a91e0044/cryptography-46.0.5-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:50bfb6925eff619c9c023b967d5b77a54e04256c4281b0e21336a130cd7fc263", size = 4277528, upload-time = "2026-02-10T19:17:13.853Z" },
+    { url = "https://files.pythonhosted.org/packages/22/29/c2e812ebc38c57b40e7c583895e73c8c5adb4d1e4a0cc4c5a4fdab2b1acc/cryptography-46.0.5-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:803812e111e75d1aa73690d2facc295eaefd4439be1023fefc4995eaea2af90d", size = 4947993, upload-time = "2026-02-10T19:17:15.618Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/e7/237155ae19a9023de7e30ec64e5d99a9431a567407ac21170a046d22a5a3/cryptography-46.0.5-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3ee190460e2fbe447175cda91b88b84ae8322a104fc27766ad09428754a618ed", size = 4456855, upload-time = "2026-02-10T19:17:17.221Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/87/fc628a7ad85b81206738abbd213b07702bcbdada1dd43f72236ef3cffbb5/cryptography-46.0.5-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:f145bba11b878005c496e93e257c1e88f154d278d2638e6450d17e0f31e558d2", size = 3984635, upload-time = "2026-02-10T19:17:18.792Z" },
+    { url = "https://files.pythonhosted.org/packages/84/29/65b55622bde135aedf4565dc509d99b560ee4095e56989e815f8fd2aa910/cryptography-46.0.5-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:e9251e3be159d1020c4030bd2e5f84d6a43fe54b6c19c12f51cde9542a2817b2", size = 4277038, upload-time = "2026-02-10T19:17:20.256Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/36/45e76c68d7311432741faf1fbf7fac8a196a0a735ca21f504c75d37e2558/cryptography-46.0.5-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:47fb8a66058b80e509c47118ef8a75d14c455e81ac369050f20ba0d23e77fee0", size = 4912181, upload-time = "2026-02-10T19:17:21.825Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/1a/c1ba8fead184d6e3d5afcf03d569acac5ad063f3ac9fb7258af158f7e378/cryptography-46.0.5-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:4c3341037c136030cb46e4b1e17b7418ea4cbd9dd207e4a6f3b2b24e0d4ac731", size = 4456482, upload-time = "2026-02-10T19:17:25.133Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/e5/3fb22e37f66827ced3b902cf895e6a6bc1d095b5b26be26bd13c441fdf19/cryptography-46.0.5-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:890bcb4abd5a2d3f852196437129eb3667d62630333aacc13dfd470fad3aaa82", size = 4405497, upload-time = "2026-02-10T19:17:26.66Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/df/9d58bb32b1121a8a2f27383fabae4d63080c7ca60b9b5c88be742be04ee7/cryptography-46.0.5-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:80a8d7bfdf38f87ca30a5391c0c9ce4ed2926918e017c29ddf643d0ed2778ea1", size = 4667819, upload-time = "2026-02-10T19:17:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/ed/325d2a490c5e94038cdb0117da9397ece1f11201f425c4e9c57fe5b9f08b/cryptography-46.0.5-cp311-abi3-win32.whl", hash = "sha256:60ee7e19e95104d4c03871d7d7dfb3d22ef8a9b9c6778c94e1c8fcc8365afd48", size = 3028230, upload-time = "2026-02-10T19:17:30.518Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/5a/ac0f49e48063ab4255d9e3b79f5def51697fce1a95ea1370f03dc9db76f6/cryptography-46.0.5-cp311-abi3-win_amd64.whl", hash = "sha256:38946c54b16c885c72c4f59846be9743d699eee2b69b6988e0a00a01f46a61a4", size = 3480909, upload-time = "2026-02-10T19:17:32.083Z" },
+    { url = "https://files.pythonhosted.org/packages/00/13/3d278bfa7a15a96b9dc22db5a12ad1e48a9eb3d40e1827ef66a5df75d0d0/cryptography-46.0.5-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:94a76daa32eb78d61339aff7952ea819b1734b46f73646a07decb40e5b3448e2", size = 7119287, upload-time = "2026-02-10T19:17:33.801Z" },
+    { url = "https://files.pythonhosted.org/packages/67/c8/581a6702e14f0898a0848105cbefd20c058099e2c2d22ef4e476dfec75d7/cryptography-46.0.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5be7bf2fb40769e05739dd0046e7b26f9d4670badc7b032d6ce4db64dddc0678", size = 4265728, upload-time = "2026-02-10T19:17:35.569Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/4a/ba1a65ce8fc65435e5a849558379896c957870dd64fecea97b1ad5f46a37/cryptography-46.0.5-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fe346b143ff9685e40192a4960938545c699054ba11d4f9029f94751e3f71d87", size = 4408287, upload-time = "2026-02-10T19:17:36.938Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/67/8ffdbf7b65ed1ac224d1c2df3943553766914a8ca718747ee3871da6107e/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:c69fd885df7d089548a42d5ec05be26050ebcd2283d89b3d30676eb32ff87dee", size = 4270291, upload-time = "2026-02-10T19:17:38.748Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/e5/f52377ee93bc2f2bba55a41a886fd208c15276ffbd2569f2ddc89d50e2c5/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:8293f3dea7fc929ef7240796ba231413afa7b68ce38fd21da2995549f5961981", size = 4927539, upload-time = "2026-02-10T19:17:40.241Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/02/cfe39181b02419bbbbcf3abdd16c1c5c8541f03ca8bda240debc467d5a12/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:1abfdb89b41c3be0365328a410baa9df3ff8a9110fb75e7b52e66803ddabc9a9", size = 4442199, upload-time = "2026-02-10T19:17:41.789Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/96/2fcaeb4873e536cf71421a388a6c11b5bc846e986b2b069c79363dc1648e/cryptography-46.0.5-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:d66e421495fdb797610a08f43b05269e0a5ea7f5e652a89bfd5a7d3c1dee3648", size = 3960131, upload-time = "2026-02-10T19:17:43.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/d2/b27631f401ddd644e94c5cf33c9a4069f72011821cf3dc7309546b0642a0/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:4e817a8920bfbcff8940ecfd60f23d01836408242b30f1a708d93198393a80b4", size = 4270072, upload-time = "2026-02-10T19:17:45.481Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/a7/60d32b0370dae0b4ebe55ffa10e8599a2a59935b5ece1b9f06edb73abdeb/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:68f68d13f2e1cb95163fa3b4db4bf9a159a418f5f6e7242564fc75fcae667fd0", size = 4892170, upload-time = "2026-02-10T19:17:46.997Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/b9/cf73ddf8ef1164330eb0b199a589103c363afa0cf794218c24d524a58eab/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:a3d1fae9863299076f05cb8a778c467578262fae09f9dc0ee9b12eb4268ce663", size = 4441741, upload-time = "2026-02-10T19:17:48.661Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/eb/eee00b28c84c726fe8fa0158c65afe312d9c3b78d9d01daf700f1f6e37ff/cryptography-46.0.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4143987a42a2397f2fc3b4d7e3a7d313fbe684f67ff443999e803dd75a76826", size = 4396728, upload-time = "2026-02-10T19:17:50.058Z" },
+    { url = "https://files.pythonhosted.org/packages/65/f4/6bc1a9ed5aef7145045114b75b77c2a8261b4d38717bd8dea111a63c3442/cryptography-46.0.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:7d731d4b107030987fd61a7f8ab512b25b53cef8f233a97379ede116f30eb67d", size = 4652001, upload-time = "2026-02-10T19:17:51.54Z" },
+    { url = "https://files.pythonhosted.org/packages/86/ef/5d00ef966ddd71ac2e6951d278884a84a40ffbd88948ef0e294b214ae9e4/cryptography-46.0.5-cp314-cp314t-win32.whl", hash = "sha256:c3bcce8521d785d510b2aad26ae2c966092b7daa8f45dd8f44734a104dc0bc1a", size = 3003637, upload-time = "2026-02-10T19:17:52.997Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/57/f3f4160123da6d098db78350fdfd9705057aad21de7388eacb2401dceab9/cryptography-46.0.5-cp314-cp314t-win_amd64.whl", hash = "sha256:4d8ae8659ab18c65ced284993c2265910f6c9e650189d4e3f68445ef82a810e4", size = 3469487, upload-time = "2026-02-10T19:17:54.549Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/fa/a66aa722105ad6a458bebd64086ca2b72cdd361fed31763d20390f6f1389/cryptography-46.0.5-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:4108d4c09fbbf2789d0c926eb4152ae1760d5a2d97612b92d508d96c861e4d31", size = 7170514, upload-time = "2026-02-10T19:17:56.267Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/04/c85bdeab78c8bc77b701bf0d9bdcf514c044e18a46dcff330df5448631b0/cryptography-46.0.5-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7d1f30a86d2757199cb2d56e48cce14deddf1f9c95f1ef1b64ee91ea43fe2e18", size = 4275349, upload-time = "2026-02-10T19:17:58.419Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/32/9b87132a2f91ee7f5223b091dc963055503e9b442c98fc0b8a5ca765fab0/cryptography-46.0.5-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:039917b0dc418bb9f6edce8a906572d69e74bd330b0b3fea4f79dab7f8ddd235", size = 4420667, upload-time = "2026-02-10T19:18:00.619Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/a6/a7cb7010bec4b7c5692ca6f024150371b295ee1c108bdc1c400e4c44562b/cryptography-46.0.5-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:ba2a27ff02f48193fc4daeadf8ad2590516fa3d0adeeb34336b96f7fa64c1e3a", size = 4276980, upload-time = "2026-02-10T19:18:02.379Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/7c/c4f45e0eeff9b91e3f12dbd0e165fcf2a38847288fcfd889deea99fb7b6d/cryptography-46.0.5-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:61aa400dce22cb001a98014f647dc21cda08f7915ceb95df0c9eaf84b4b6af76", size = 4939143, upload-time = "2026-02-10T19:18:03.964Z" },
+    { url = "https://files.pythonhosted.org/packages/37/19/e1b8f964a834eddb44fa1b9a9976f4e414cbb7aa62809b6760c8803d22d1/cryptography-46.0.5-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3ce58ba46e1bc2aac4f7d9290223cead56743fa6ab94a5d53292ffaac6a91614", size = 4453674, upload-time = "2026-02-10T19:18:05.588Z" },
+    { url = "https://files.pythonhosted.org/packages/db/ed/db15d3956f65264ca204625597c410d420e26530c4e2943e05a0d2f24d51/cryptography-46.0.5-cp38-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:420d0e909050490d04359e7fdb5ed7e667ca5c3c402b809ae2563d7e66a92229", size = 3978801, upload-time = "2026-02-10T19:18:07.167Z" },
+    { url = "https://files.pythonhosted.org/packages/41/e2/df40a31d82df0a70a0daf69791f91dbb70e47644c58581d654879b382d11/cryptography-46.0.5-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:582f5fcd2afa31622f317f80426a027f30dc792e9c80ffee87b993200ea115f1", size = 4276755, upload-time = "2026-02-10T19:18:09.813Z" },
+    { url = "https://files.pythonhosted.org/packages/33/45/726809d1176959f4a896b86907b98ff4391a8aa29c0aaaf9450a8a10630e/cryptography-46.0.5-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:bfd56bb4b37ed4f330b82402f6f435845a5f5648edf1ad497da51a8452d5d62d", size = 4901539, upload-time = "2026-02-10T19:18:11.263Z" },
+    { url = "https://files.pythonhosted.org/packages/99/0f/a3076874e9c88ecb2ecc31382f6e7c21b428ede6f55aafa1aa272613e3cd/cryptography-46.0.5-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:a3d507bb6a513ca96ba84443226af944b0f7f47dcc9a399d110cd6146481d24c", size = 4452794, upload-time = "2026-02-10T19:18:12.914Z" },
+    { url = "https://files.pythonhosted.org/packages/02/ef/ffeb542d3683d24194a38f66ca17c0a4b8bf10631feef44a7ef64e631b1a/cryptography-46.0.5-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9f16fbdf4da055efb21c22d81b89f155f02ba420558db21288b3d0035bafd5f4", size = 4404160, upload-time = "2026-02-10T19:18:14.375Z" },
+    { url = "https://files.pythonhosted.org/packages/96/93/682d2b43c1d5f1406ed048f377c0fc9fc8f7b0447a478d5c65ab3d3a66eb/cryptography-46.0.5-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ced80795227d70549a411a4ab66e8ce307899fad2220ce5ab2f296e687eacde9", size = 4667123, upload-time = "2026-02-10T19:18:15.886Z" },
+    { url = "https://files.pythonhosted.org/packages/45/2d/9c5f2926cb5300a8eefc3f4f0b3f3df39db7f7ce40c8365444c49363cbda/cryptography-46.0.5-cp38-abi3-win32.whl", hash = "sha256:02f547fce831f5096c9a567fd41bc12ca8f11df260959ecc7c3202555cc47a72", size = 3010220, upload-time = "2026-02-10T19:18:17.361Z" },
+    { url = "https://files.pythonhosted.org/packages/48/ef/0c2f4a8e31018a986949d34a01115dd057bf536905dca38897bacd21fac3/cryptography-46.0.5-cp38-abi3-win_amd64.whl", hash = "sha256:556e106ee01aa13484ce9b0239bca667be5004efb0aabbed28d353df86445595", size = 3467050, upload-time = "2026-02-10T19:18:18.899Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/dd/2d9fdb07cebdf3d51179730afb7d5e576153c6744c3ff8fded23030c204e/cryptography-46.0.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:3b4995dc971c9fb83c25aa44cf45f02ba86f71ee600d81091c2f0cbae116b06c", size = 3476964, upload-time = "2026-02-10T19:18:20.687Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/6f/6cc6cc9955caa6eaf83660b0da2b077c7fe8ff9950a3c5e45d605038d439/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:bc84e875994c3b445871ea7181d424588171efec3e185dced958dad9e001950a", size = 4218321, upload-time = "2026-02-10T19:18:22.349Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/5d/c4da701939eeee699566a6c1367427ab91a8b7088cc2328c09dbee940415/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:2ae6971afd6246710480e3f15824ed3029a60fc16991db250034efd0b9fb4356", size = 4381786, upload-time = "2026-02-10T19:18:24.529Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/97/a538654732974a94ff96c1db621fa464f455c02d4bb7d2652f4edc21d600/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:d861ee9e76ace6cf36a6a89b959ec08e7bc2493ee39d07ffe5acb23ef46d27da", size = 4217990, upload-time = "2026-02-10T19:18:25.957Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/11/7e500d2dd3ba891197b9efd2da5454b74336d64a7cc419aa7327ab74e5f6/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:2b7a67c9cd56372f3249b39699f2ad479f6991e62ea15800973b956f4b73e257", size = 4381252, upload-time = "2026-02-10T19:18:27.496Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/58/6b3d24e6b9bc474a2dcdee65dfd1f008867015408a271562e4b690561a4d/cryptography-46.0.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:8456928655f856c6e1533ff59d5be76578a7157224dbd9ce6872f25055ab9ab7", size = 3407605, upload-time = "2026-02-10T19:18:29.233Z" },
 ]
 
 [[package]]
@@ -884,7 +879,7 @@ wheels = [
 
 [[package]]
 name = "langchain-core"
-version = "1.2.7"
+version = "1.2.11"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jsonpatch", marker = "python_full_version >= '3.11'" },
@@ -896,9 +891,9 @@ dependencies = [
     { name = "typing-extensions", marker = "python_full_version >= '3.11'" },
     { name = "uuid-utils", marker = "python_full_version >= '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a2/0e/664d8d81b3493e09cbab72448d2f9d693d1fa5aa2bcc488602203a9b6da0/langchain_core-1.2.7.tar.gz", hash = "sha256:e1460639f96c352b4a41c375f25aeb8d16ffc1769499fb1c20503aad59305ced", size = 837039, upload-time = "2026-01-09T17:44:25.505Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/12/17/1943cedfc118e04b8128e4c3e1dbf0fa0ea58eefddbb6198cfd699d19f01/langchain_core-1.2.11.tar.gz", hash = "sha256:f164bb36602dd74a3a50c1334fca75309ad5ed95767acdfdbb9fa95ce28a1e01", size = 831211, upload-time = "2026-02-10T20:35:28.35Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6e/6f/34a9fba14d191a67f7e2ee3dbce3e9b86d2fa7310e2c7f2c713583481bd2/langchain_core-1.2.7-py3-none-any.whl", hash = "sha256:452f4fef7a3d883357b22600788d37e3d8854ef29da345b7ac7099f33c31828b", size = 490232, upload-time = "2026-01-09T17:44:24.236Z" },
+    { url = "https://files.pythonhosted.org/packages/10/30/1f80e3fc674353cad975ed5294353d42512535d2094ef032c06454c2c873/langchain_core-1.2.11-py3-none-any.whl", hash = "sha256:ae11ceb8dda60d0b9d09e763116e592f1683327c17be5b715f350fd29aee65d3", size = 500062, upload-time = "2026-02-10T20:35:26.698Z" },
 ]
 
 [[package]]
@@ -1076,15 +1071,15 @@ wheels = [
 
 [[package]]
 name = "langgraph-sdk"
-version = "0.3.3"
+version = "0.3.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx", marker = "python_full_version >= '3.11'" },
     { name = "orjson", marker = "python_full_version >= '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c3/0f/ed0634c222eed48a31ba48eab6881f94ad690d65e44fe7ca838240a260c1/langgraph_sdk-0.3.3.tar.gz", hash = "sha256:c34c3dce3b6848755eb61f0c94369d1ba04aceeb1b76015db1ea7362c544fb26", size = 130589, upload-time = "2026-01-13T00:30:43.894Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/60/2b/2dae368ac76e315197f07ab58077aadf20833c226fbfd450d71745850314/langgraph_sdk-0.3.5.tar.gz", hash = "sha256:64669e9885a908578eed921ef9a8e52b8d0cd38db1e3e5d6d299d4e6f8830ac0", size = 177470, upload-time = "2026-02-10T16:56:09.18Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6e/be/4ad511bacfdd854afb12974f407cb30010dceb982dc20c55491867b34526/langgraph_sdk-0.3.3-py3-none-any.whl", hash = "sha256:a52ebaf09d91143e55378bb2d0b033ed98f57f48c9ad35c8f81493b88705fc7b", size = 67021, upload-time = "2026-01-13T00:30:42.264Z" },
+    { url = "https://files.pythonhosted.org/packages/84/d5/a14d957c515ba7a9713bf0f03f2b9277979c403bc50f829bdfd54ae7dc9e/langgraph_sdk-0.3.5-py3-none-any.whl", hash = "sha256:bcfa1dcbddadb604076ce46f5e08969538735e5ac47fa863d4fac5a512dab5c9", size = 70851, upload-time = "2026-02-10T16:56:07.983Z" },
 ]
 
 [[package]]
@@ -1596,17 +1591,17 @@ wheels = [
 
 [[package]]
 name = "protobuf"
-version = "6.33.4"
+version = "6.33.5"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/53/b8/cda15d9d46d03d4aa3a67cb6bffe05173440ccf86a9541afaf7ac59a1b6b/protobuf-6.33.4.tar.gz", hash = "sha256:dc2e61bca3b10470c1912d166fe0af67bfc20eb55971dcef8dfa48ce14f0ed91", size = 444346, upload-time = "2026-01-12T18:33:40.109Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ba/25/7c72c307aafc96fa87062aa6291d9f7c94836e43214d43722e86037aac02/protobuf-6.33.5.tar.gz", hash = "sha256:6ddcac2a081f8b7b9642c09406bc6a4290128fce5f471cddd165960bb9119e5c", size = 444465, upload-time = "2026-01-29T21:51:33.494Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e0/be/24ef9f3095bacdf95b458543334d0c4908ccdaee5130420bf064492c325f/protobuf-6.33.4-cp310-abi3-win32.whl", hash = "sha256:918966612c8232fc6c24c78e1cd89784307f5814ad7506c308ee3cf86662850d", size = 425612, upload-time = "2026-01-12T18:33:29.656Z" },
-    { url = "https://files.pythonhosted.org/packages/31/ad/e5693e1974a28869e7cd244302911955c1cebc0161eb32dfa2b25b6e96f0/protobuf-6.33.4-cp310-abi3-win_amd64.whl", hash = "sha256:8f11ffae31ec67fc2554c2ef891dcb561dae9a2a3ed941f9e134c2db06657dbc", size = 436962, upload-time = "2026-01-12T18:33:31.345Z" },
-    { url = "https://files.pythonhosted.org/packages/66/15/6ee23553b6bfd82670207ead921f4d8ef14c107e5e11443b04caeb5ab5ec/protobuf-6.33.4-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:2fe67f6c014c84f655ee06f6f66213f9254b3a8b6bda6cda0ccd4232c73c06f0", size = 427612, upload-time = "2026-01-12T18:33:32.646Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/48/d301907ce6d0db75f959ca74f44b475a9caa8fcba102d098d3c3dd0f2d3f/protobuf-6.33.4-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:757c978f82e74d75cba88eddec479df9b99a42b31193313b75e492c06a51764e", size = 324484, upload-time = "2026-01-12T18:33:33.789Z" },
-    { url = "https://files.pythonhosted.org/packages/92/1c/e53078d3f7fe710572ab2dcffd993e1e3b438ae71cfc031b71bae44fcb2d/protobuf-6.33.4-cp39-abi3-manylinux2014_s390x.whl", hash = "sha256:c7c64f259c618f0bef7bee042075e390debbf9682334be2b67408ec7c1c09ee6", size = 339256, upload-time = "2026-01-12T18:33:35.231Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/8e/971c0edd084914f7ee7c23aa70ba89e8903918adca179319ee94403701d5/protobuf-6.33.4-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:3df850c2f8db9934de4cf8f9152f8dc2558f49f298f37f90c517e8e5c84c30e9", size = 323311, upload-time = "2026-01-12T18:33:36.305Z" },
-    { url = "https://files.pythonhosted.org/packages/75/b1/1dc83c2c661b4c62d56cc081706ee33a4fc2835bd90f965baa2663ef7676/protobuf-6.33.4-py3-none-any.whl", hash = "sha256:1fe3730068fcf2e595816a6c34fe66eeedd37d51d0400b72fabc848811fdc1bc", size = 170532, upload-time = "2026-01-12T18:33:39.199Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/79/af92d0a8369732b027e6d6084251dd8e782c685c72da161bd4a2e00fbabb/protobuf-6.33.5-cp310-abi3-win32.whl", hash = "sha256:d71b040839446bac0f4d162e758bea99c8251161dae9d0983a3b88dee345153b", size = 425769, upload-time = "2026-01-29T21:51:21.751Z" },
+    { url = "https://files.pythonhosted.org/packages/55/75/bb9bc917d10e9ee13dee8607eb9ab963b7cf8be607c46e7862c748aa2af7/protobuf-6.33.5-cp310-abi3-win_amd64.whl", hash = "sha256:3093804752167bcab3998bec9f1048baae6e29505adaf1afd14a37bddede533c", size = 437118, upload-time = "2026-01-29T21:51:24.022Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/6b/e48dfc1191bc5b52950246275bf4089773e91cb5ba3592621723cdddca62/protobuf-6.33.5-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:a5cb85982d95d906df1e2210e58f8e4f1e3cdc088e52c921a041f9c9a0386de5", size = 427766, upload-time = "2026-01-29T21:51:25.413Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/b1/c79468184310de09d75095ed1314b839eb2f72df71097db9d1404a1b2717/protobuf-6.33.5-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:9b71e0281f36f179d00cbcb119cb19dec4d14a81393e5ea220f64b286173e190", size = 324638, upload-time = "2026-01-29T21:51:26.423Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/f5/65d838092fd01c44d16037953fd4c2cc851e783de9b8f02b27ec4ffd906f/protobuf-6.33.5-cp39-abi3-manylinux2014_s390x.whl", hash = "sha256:8afa18e1d6d20af15b417e728e9f60f3aa108ee76f23c3b2c07a2c3b546d3afd", size = 339411, upload-time = "2026-01-29T21:51:27.446Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/53/a9443aa3ca9ba8724fdfa02dd1887c1bcd8e89556b715cfbacca6b63dbec/protobuf-6.33.5-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:cbf16ba3350fb7b889fca858fb215967792dc125b35c7976ca4818bee3521cf0", size = 323465, upload-time = "2026-01-29T21:51:28.925Z" },
+    { url = "https://files.pythonhosted.org/packages/57/bf/2086963c69bdac3d7cff1cc7ff79b8ce5ea0bec6797a017e1be338a46248/protobuf-6.33.5-py3-none-any.whl", hash = "sha256:69915a973dd0f60f31a08b8318b73eab2bd6a392c79184b3612226b0a3f8ec02", size = 170687, upload-time = "2026-01-29T21:51:32.557Z" },
 ]
 
 [[package]]
@@ -1967,28 +1962,27 @@ wheels = [
 
 [[package]]
 name = "ruff"
-version = "0.14.14"
+version = "0.15.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/2e/06/f71e3a86b2df0dfa2d2f72195941cd09b44f87711cb7fa5193732cb9a5fc/ruff-0.14.14.tar.gz", hash = "sha256:2d0f819c9a90205f3a867dbbd0be083bee9912e170fd7d9704cc8ae45824896b", size = 4515732, upload-time = "2026-01-22T22:30:17.527Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/dc/4e6ac71b511b141cf626357a3946679abeba4cf67bc7cc5a17920f31e10d/ruff-0.15.1.tar.gz", hash = "sha256:c590fe13fb57c97141ae975c03a1aedb3d3156030cabd740d6ff0b0d601e203f", size = 4540855, upload-time = "2026-02-12T23:09:09.998Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d2/89/20a12e97bc6b9f9f68343952da08a8099c57237aef953a56b82711d55edd/ruff-0.14.14-py3-none-linux_armv6l.whl", hash = "sha256:7cfe36b56e8489dee8fbc777c61959f60ec0f1f11817e8f2415f429552846aed", size = 10467650, upload-time = "2026-01-22T22:30:08.578Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/b1/c5de3fd2d5a831fcae21beda5e3589c0ba67eec8202e992388e4b17a6040/ruff-0.14.14-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:6006a0082336e7920b9573ef8a7f52eec837add1265cc74e04ea8a4368cd704c", size = 10883245, upload-time = "2026-01-22T22:30:04.155Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/7c/3c1db59a10e7490f8f6f8559d1db8636cbb13dccebf18686f4e3c9d7c772/ruff-0.14.14-py3-none-macosx_11_0_arm64.whl", hash = "sha256:026c1d25996818f0bf498636686199d9bd0d9d6341c9c2c3b62e2a0198b758de", size = 10231273, upload-time = "2026-01-22T22:30:34.642Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/6e/5e0e0d9674be0f8581d1f5e0f0a04761203affce3232c1a1189d0e3b4dad/ruff-0.14.14-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f666445819d31210b71e0a6d1c01e24447a20b85458eea25a25fe8142210ae0e", size = 10585753, upload-time = "2026-01-22T22:30:31.781Z" },
-    { url = "https://files.pythonhosted.org/packages/23/09/754ab09f46ff1884d422dc26d59ba18b4e5d355be147721bb2518aa2a014/ruff-0.14.14-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3c0f18b922c6d2ff9a5e6c3ee16259adc513ca775bcf82c67ebab7cbd9da5bc8", size = 10286052, upload-time = "2026-01-22T22:30:24.827Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/cc/e71f88dd2a12afb5f50733851729d6b571a7c3a35bfdb16c3035132675a0/ruff-0.14.14-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1629e67489c2dea43e8658c3dba659edbfd87361624b4040d1df04c9740ae906", size = 11043637, upload-time = "2026-01-22T22:30:13.239Z" },
-    { url = "https://files.pythonhosted.org/packages/67/b2/397245026352494497dac935d7f00f1468c03a23a0c5db6ad8fc49ca3fb2/ruff-0.14.14-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:27493a2131ea0f899057d49d303e4292b2cae2bb57253c1ed1f256fbcd1da480", size = 12194761, upload-time = "2026-01-22T22:30:22.542Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/06/06ef271459f778323112c51b7587ce85230785cd64e91772034ddb88f200/ruff-0.14.14-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:01ff589aab3f5b539e35db38425da31a57521efd1e4ad1ae08fc34dbe30bd7df", size = 12005701, upload-time = "2026-01-22T22:30:20.499Z" },
-    { url = "https://files.pythonhosted.org/packages/41/d6/99364514541cf811ccc5ac44362f88df66373e9fec1b9d1c4cc830593fe7/ruff-0.14.14-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1cc12d74eef0f29f51775f5b755913eb523546b88e2d733e1d701fe65144e89b", size = 11282455, upload-time = "2026-01-22T22:29:59.679Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/71/37daa46f89475f8582b7762ecd2722492df26421714a33e72ccc9a84d7a5/ruff-0.14.14-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bb8481604b7a9e75eff53772496201690ce2687067e038b3cc31aaf16aa0b974", size = 11215882, upload-time = "2026-01-22T22:29:57.032Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/10/a31f86169ec91c0705e618443ee74ede0bdd94da0a57b28e72db68b2dbac/ruff-0.14.14-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:14649acb1cf7b5d2d283ebd2f58d56b75836ed8c6f329664fa91cdea19e76e66", size = 11180549, upload-time = "2026-01-22T22:30:27.175Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/1e/c723f20536b5163adf79bdd10c5f093414293cdf567eed9bdb7b83940f3f/ruff-0.14.14-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:e8058d2145566510790eab4e2fad186002e288dec5e0d343a92fe7b0bc1b3e13", size = 10543416, upload-time = "2026-01-22T22:30:01.964Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/34/8a84cea7e42c2d94ba5bde1d7a4fae164d6318f13f933d92da6d7c2041ff/ruff-0.14.14-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:e651e977a79e4c758eb807f0481d673a67ffe53cfa92209781dfa3a996cf8412", size = 10285491, upload-time = "2026-01-22T22:30:29.51Z" },
-    { url = "https://files.pythonhosted.org/packages/55/ef/b7c5ea0be82518906c978e365e56a77f8de7678c8bb6651ccfbdc178c29f/ruff-0.14.14-py3-none-musllinux_1_2_i686.whl", hash = "sha256:cc8b22da8d9d6fdd844a68ae937e2a0adf9b16514e9a97cc60355e2d4b219fc3", size = 10733525, upload-time = "2026-01-22T22:30:06.499Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/5b/aaf1dfbcc53a2811f6cc0a1759de24e4b03e02ba8762daabd9b6bd8c59e3/ruff-0.14.14-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:16bc890fb4cc9781bb05beb5ab4cd51be9e7cb376bf1dd3580512b24eb3fda2b", size = 11315626, upload-time = "2026-01-22T22:30:36.848Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/aa/9f89c719c467dfaf8ad799b9bae0df494513fb21d31a6059cb5870e57e74/ruff-0.14.14-py3-none-win32.whl", hash = "sha256:b530c191970b143375b6a68e6f743800b2b786bbcf03a7965b06c4bf04568167", size = 10502442, upload-time = "2026-01-22T22:30:38.93Z" },
-    { url = "https://files.pythonhosted.org/packages/87/44/90fa543014c45560cae1fffc63ea059fb3575ee6e1cb654562197e5d16fb/ruff-0.14.14-py3-none-win_amd64.whl", hash = "sha256:3dde1435e6b6fe5b66506c1dff67a421d0b7f6488d466f651c07f4cab3bf20fd", size = 11630486, upload-time = "2026-01-22T22:30:10.852Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/6a/40fee331a52339926a92e17ae748827270b288a35ef4a15c9c8f2ec54715/ruff-0.14.14-py3-none-win_arm64.whl", hash = "sha256:56e6981a98b13a32236a72a8da421d7839221fa308b223b9283312312e5ac76c", size = 10920448, upload-time = "2026-01-22T22:30:15.417Z" },
+    { url = "https://files.pythonhosted.org/packages/23/bf/e6e4324238c17f9d9120a9d60aa99a7daaa21204c07fcd84e2ef03bb5fd1/ruff-0.15.1-py3-none-linux_armv6l.whl", hash = "sha256:b101ed7cf4615bda6ffe65bdb59f964e9f4a0d3f85cbf0e54f0ab76d7b90228a", size = 10367819, upload-time = "2026-02-12T23:09:03.598Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/ea/c8f89d32e7912269d38c58f3649e453ac32c528f93bb7f4219258be2e7ed/ruff-0.15.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:939c995e9277e63ea632cc8d3fae17aa758526f49a9a850d2e7e758bfef46602", size = 10798618, upload-time = "2026-02-12T23:09:22.928Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/0f/1d0d88bc862624247d82c20c10d4c0f6bb2f346559d8af281674cf327f15/ruff-0.15.1-py3-none-macosx_11_0_arm64.whl", hash = "sha256:1d83466455fdefe60b8d9c8df81d3c1bbb2115cede53549d3b522ce2bc703899", size = 10148518, upload-time = "2026-02-12T23:08:58.339Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/c8/291c49cefaa4a9248e986256df2ade7add79388fe179e0691be06fae6f37/ruff-0.15.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9457e3c3291024866222b96108ab2d8265b477e5b1534c7ddb1810904858d16", size = 10518811, upload-time = "2026-02-12T23:09:31.865Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/1a/f5707440e5ae43ffa5365cac8bbb91e9665f4a883f560893829cf16a606b/ruff-0.15.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:92c92b003e9d4f7fbd33b1867bb15a1b785b1735069108dfc23821ba045b29bc", size = 10196169, upload-time = "2026-02-12T23:09:17.306Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/ff/26ddc8c4da04c8fd3ee65a89c9fb99eaa5c30394269d424461467be2271f/ruff-0.15.1-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fe5c41ab43e3a06778844c586251eb5a510f67125427625f9eb2b9526535779", size = 10990491, upload-time = "2026-02-12T23:09:25.503Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/00/50920cb385b89413f7cdb4bb9bc8fc59c1b0f30028d8bccc294189a54955/ruff-0.15.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66a6dd6df4d80dc382c6484f8ce1bcceb55c32e9f27a8b94c32f6c7331bf14fb", size = 11843280, upload-time = "2026-02-12T23:09:19.88Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/6d/2f5cad8380caf5632a15460c323ae326f1e1a2b5b90a6ee7519017a017ca/ruff-0.15.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6a4a42cbb8af0bda9bcd7606b064d7c0bc311a88d141d02f78920be6acb5aa83", size = 11274336, upload-time = "2026-02-12T23:09:14.907Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/1d/5f56cae1d6c40b8a318513599b35ea4b075d7dc1cd1d04449578c29d1d75/ruff-0.15.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4ab064052c31dddada35079901592dfba2e05f5b1e43af3954aafcbc1096a5b2", size = 11137288, upload-time = "2026-02-12T23:09:07.475Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/20/6f8d7d8f768c93b0382b33b9306b3b999918816da46537d5a61635514635/ruff-0.15.1-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:5631c940fe9fe91f817a4c2ea4e81f47bee3ca4aa646134a24374f3c19ad9454", size = 11070681, upload-time = "2026-02-12T23:08:55.43Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/67/d640ac76069f64cdea59dba02af2e00b1fa30e2103c7f8d049c0cff4cafd/ruff-0.15.1-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:68138a4ba184b4691ccdc39f7795c66b3c68160c586519e7e8444cf5a53e1b4c", size = 10486401, upload-time = "2026-02-12T23:09:27.927Z" },
+    { url = "https://files.pythonhosted.org/packages/65/3d/e1429f64a3ff89297497916b88c32a5cc88eeca7e9c787072d0e7f1d3e1e/ruff-0.15.1-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:518f9af03bfc33c03bdb4cb63fabc935341bb7f54af500f92ac309ecfbba6330", size = 10197452, upload-time = "2026-02-12T23:09:12.147Z" },
+    { url = "https://files.pythonhosted.org/packages/78/83/e2c3bade17dad63bf1e1c2ffaf11490603b760be149e1419b07049b36ef2/ruff-0.15.1-py3-none-musllinux_1_2_i686.whl", hash = "sha256:da79f4d6a826caaea95de0237a67e33b81e6ec2e25fc7e1993a4015dffca7c61", size = 10693900, upload-time = "2026-02-12T23:09:34.418Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/27/fdc0e11a813e6338e0706e8b39bb7a1d61ea5b36873b351acee7e524a72a/ruff-0.15.1-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:3dd86dccb83cd7d4dcfac303ffc277e6048600dfc22e38158afa208e8bf94a1f", size = 11227302, upload-time = "2026-02-12T23:09:36.536Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/58/ac864a75067dcbd3b95be5ab4eb2b601d7fbc3d3d736a27e391a4f92a5c1/ruff-0.15.1-py3-none-win32.whl", hash = "sha256:660975d9cb49b5d5278b12b03bb9951d554543a90b74ed5d366b20e2c57c2098", size = 10462555, upload-time = "2026-02-12T23:09:29.899Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/5e/d4ccc8a27ecdb78116feac4935dfc39d1304536f4296168f91ed3ec00cd2/ruff-0.15.1-py3-none-win_amd64.whl", hash = "sha256:c820fef9dd5d4172a6570e5721704a96c6679b80cf7be41659ed439653f62336", size = 11599956, upload-time = "2026-02-12T23:09:01.157Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/07/5bda6a85b220c64c65686bc85bd0bbb23b29c62b3a9f9433fa55f17cda93/ruff-0.15.1-py3-none-win_arm64.whl", hash = "sha256:5ff7d5f0f88567850f45081fac8f4ec212be8d0b963e385c3f7d0d2eb4899416", size = 10874604, upload-time = "2026-02-12T23:09:05.515Z" },
 ]
 
 [[package]]

libs/langgraph/pyproject.toml

@@ -60,7 +60,7 @@ test = [
     "langgraph-checkpoint-postgres",
     "langgraph-sdk",
     "psycopg[binary]",
-    "uvloop==0.21.0beta1",
+    "uvloop==0.22.1",
     "pyperf",
     "py-spy",
     "pycryptodome",

libs/langgraph/uv.lock

@@ -524,66 +524,61 @@ toml = [
 
 [[package]]
 name = "cryptography"
-version = "46.0.3"
+version = "46.0.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cffi", marker = "python_full_version >= '3.11' and python_full_version < '3.14' and platform_python_implementation != 'PyPy'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/9f/33/c00162f49c0e2fe8064a62cb92b93e50c74a72bc370ab92f86112b33ff62/cryptography-46.0.3.tar.gz", hash = "sha256:a8b17438104fed022ce745b362294d9ce35b4c2e45c1d958ad4a4b019285f4a1", size = 749258, upload-time = "2025-10-15T23:18:31.74Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/60/04/ee2a9e8542e4fa2773b81771ff8349ff19cdd56b7258a0cc442639052edb/cryptography-46.0.5.tar.gz", hash = "sha256:abace499247268e3757271b2f1e244b36b06f8515cf27c4d49468fc9eb16e93d", size = 750064, upload-time = "2026-02-10T19:18:38.255Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1d/42/9c391dd801d6cf0d561b5890549d4b27bafcc53b39c31a817e69d87c625b/cryptography-46.0.3-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:109d4ddfadf17e8e7779c39f9b18111a09efb969a301a31e987416a0191ed93a", size = 7225004, upload-time = "2025-10-15T23:16:52.239Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/67/38769ca6b65f07461eb200e85fc1639b438bdc667be02cf7f2cd6a64601c/cryptography-46.0.3-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:09859af8466b69bc3c27bdf4f5d84a665e0f7ab5088412e9e2ec49758eca5cbc", size = 4296667, upload-time = "2025-10-15T23:16:54.369Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/49/498c86566a1d80e978b42f0d702795f69887005548c041636df6ae1ca64c/cryptography-46.0.3-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:01ca9ff2885f3acc98c29f1860552e37f6d7c7d013d7334ff2a9de43a449315d", size = 4450807, upload-time = "2025-10-15T23:16:56.414Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/0a/863a3604112174c8624a2ac3c038662d9e59970c7f926acdcfaed8d61142/cryptography-46.0.3-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:6eae65d4c3d33da080cff9c4ab1f711b15c1d9760809dad6ea763f3812d254cb", size = 4299615, upload-time = "2025-10-15T23:16:58.442Z" },
-    { url = "https://files.pythonhosted.org/packages/64/02/b73a533f6b64a69f3cd3872acb6ebc12aef924d8d103133bb3ea750dc703/cryptography-46.0.3-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5bf0ed4490068a2e72ac03d786693adeb909981cc596425d09032d372bcc849", size = 4016800, upload-time = "2025-10-15T23:17:00.378Z" },
-    { url = "https://files.pythonhosted.org/packages/25/d5/16e41afbfa450cde85a3b7ec599bebefaef16b5c6ba4ec49a3532336ed72/cryptography-46.0.3-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:5ecfccd2329e37e9b7112a888e76d9feca2347f12f37918facbb893d7bb88ee8", size = 4984707, upload-time = "2025-10-15T23:17:01.98Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/56/e7e69b427c3878352c2fb9b450bd0e19ed552753491d39d7d0a2f5226d41/cryptography-46.0.3-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:a2c0cd47381a3229c403062f764160d57d4d175e022c1df84e168c6251a22eec", size = 4482541, upload-time = "2025-10-15T23:17:04.078Z" },
-    { url = "https://files.pythonhosted.org/packages/78/f6/50736d40d97e8483172f1bb6e698895b92a223dba513b0ca6f06b2365339/cryptography-46.0.3-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:549e234ff32571b1f4076ac269fcce7a808d3bf98b76c8dd560e42dbc66d7d91", size = 4299464, upload-time = "2025-10-15T23:17:05.483Z" },
-    { url = "https://files.pythonhosted.org/packages/00/de/d8e26b1a855f19d9994a19c702fa2e93b0456beccbcfe437eda00e0701f2/cryptography-46.0.3-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:c0a7bb1a68a5d3471880e264621346c48665b3bf1c3759d682fc0864c540bd9e", size = 4950838, upload-time = "2025-10-15T23:17:07.425Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/29/798fc4ec461a1c9e9f735f2fc58741b0daae30688f41b2497dcbc9ed1355/cryptography-46.0.3-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:10b01676fc208c3e6feeb25a8b83d81767e8059e1fe86e1dc62d10a3018fa926", size = 4481596, upload-time = "2025-10-15T23:17:09.343Z" },
-    { url = "https://files.pythonhosted.org/packages/15/8d/03cd48b20a573adfff7652b76271078e3045b9f49387920e7f1f631d125e/cryptography-46.0.3-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0abf1ffd6e57c67e92af68330d05760b7b7efb243aab8377e583284dbab72c71", size = 4426782, upload-time = "2025-10-15T23:17:11.22Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/b1/ebacbfe53317d55cf33165bda24c86523497a6881f339f9aae5c2e13e57b/cryptography-46.0.3-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a04bee9ab6a4da801eb9b51f1b708a1b5b5c9eb48c03f74198464c66f0d344ac", size = 4698381, upload-time = "2025-10-15T23:17:12.829Z" },
-    { url = "https://files.pythonhosted.org/packages/96/92/8a6a9525893325fc057a01f654d7efc2c64b9de90413adcf605a85744ff4/cryptography-46.0.3-cp311-abi3-win32.whl", hash = "sha256:f260d0d41e9b4da1ed1e0f1ce571f97fe370b152ab18778e9e8f67d6af432018", size = 3055988, upload-time = "2025-10-15T23:17:14.65Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/bf/80fbf45253ea585a1e492a6a17efcb93467701fa79e71550a430c5e60df0/cryptography-46.0.3-cp311-abi3-win_amd64.whl", hash = "sha256:a9a3008438615669153eb86b26b61e09993921ebdd75385ddd748702c5adfddb", size = 3514451, upload-time = "2025-10-15T23:17:16.142Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/af/9b302da4c87b0beb9db4e756386a7c6c5b8003cd0e742277888d352ae91d/cryptography-46.0.3-cp311-abi3-win_arm64.whl", hash = "sha256:5d7f93296ee28f68447397bf5198428c9aeeab45705a55d53a6343455dcb2c3c", size = 2928007, upload-time = "2025-10-15T23:17:18.04Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/e2/a510aa736755bffa9d2f75029c229111a1d02f8ecd5de03078f4c18d91a3/cryptography-46.0.3-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:00a5e7e87938e5ff9ff5447ab086a5706a957137e6e433841e9d24f38a065217", size = 7158012, upload-time = "2025-10-15T23:17:19.982Z" },
-    { url = "https://files.pythonhosted.org/packages/73/dc/9aa866fbdbb95b02e7f9d086f1fccfeebf8953509b87e3f28fff927ff8a0/cryptography-46.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c8daeb2d2174beb4575b77482320303f3d39b8e81153da4f0fb08eb5fe86a6c5", size = 4288728, upload-time = "2025-10-15T23:17:21.527Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/fd/bc1daf8230eaa075184cbbf5f8cd00ba9db4fd32d63fb83da4671b72ed8a/cryptography-46.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:39b6755623145ad5eff1dab323f4eae2a32a77a7abef2c5089a04a3d04366715", size = 4435078, upload-time = "2025-10-15T23:17:23.042Z" },
-    { url = "https://files.pythonhosted.org/packages/82/98/d3bd5407ce4c60017f8ff9e63ffee4200ab3e23fe05b765cab805a7db008/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:db391fa7c66df6762ee3f00c95a89e6d428f4d60e7abc8328f4fe155b5ac6e54", size = 4293460, upload-time = "2025-10-15T23:17:24.885Z" },
-    { url = "https://files.pythonhosted.org/packages/26/e9/e23e7900983c2b8af7a08098db406cf989d7f09caea7897e347598d4cd5b/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:78a97cf6a8839a48c49271cdcbd5cf37ca2c1d6b7fdd86cc864f302b5e9bf459", size = 3995237, upload-time = "2025-10-15T23:17:26.449Z" },
-    { url = "https://files.pythonhosted.org/packages/91/15/af68c509d4a138cfe299d0d7ddb14afba15233223ebd933b4bbdbc7155d3/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:dfb781ff7eaa91a6f7fd41776ec37c5853c795d3b358d4896fdbb5df168af422", size = 4967344, upload-time = "2025-10-15T23:17:28.06Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/e3/8643d077c53868b681af077edf6b3cb58288b5423610f21c62aadcbe99f4/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:6f61efb26e76c45c4a227835ddeae96d83624fb0d29eb5df5b96e14ed1a0afb7", size = 4466564, upload-time = "2025-10-15T23:17:29.665Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/43/c1e8726fa59c236ff477ff2b5dc071e54b21e5a1e51aa2cee1676f1c986f/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:23b1a8f26e43f47ceb6d6a43115f33a5a37d57df4ea0ca295b780ae8546e8044", size = 4292415, upload-time = "2025-10-15T23:17:31.686Z" },
-    { url = "https://files.pythonhosted.org/packages/42/f9/2f8fefdb1aee8a8e3256a0568cffc4e6d517b256a2fe97a029b3f1b9fe7e/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:b419ae593c86b87014b9be7396b385491ad7f320bde96826d0dd174459e54665", size = 4931457, upload-time = "2025-10-15T23:17:33.478Z" },
-    { url = "https://files.pythonhosted.org/packages/79/30/9b54127a9a778ccd6d27c3da7563e9f2d341826075ceab89ae3b41bf5be2/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:50fc3343ac490c6b08c0cf0d704e881d0d660be923fd3076db3e932007e726e3", size = 4466074, upload-time = "2025-10-15T23:17:35.158Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/68/b4f4a10928e26c941b1b6a179143af9f4d27d88fe84a6a3c53592d2e76bf/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:22d7e97932f511d6b0b04f2bfd818d73dcd5928db509460aaf48384778eb6d20", size = 4420569, upload-time = "2025-10-15T23:17:37.188Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/49/3746dab4c0d1979888f125226357d3262a6dd40e114ac29e3d2abdf1ec55/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d55f3dffadd674514ad19451161118fd010988540cee43d8bc20675e775925de", size = 4681941, upload-time = "2025-10-15T23:17:39.236Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/30/27654c1dbaf7e4a3531fa1fc77986d04aefa4d6d78259a62c9dc13d7ad36/cryptography-46.0.3-cp314-cp314t-win32.whl", hash = "sha256:8a6e050cb6164d3f830453754094c086ff2d0b2f3a897a1d9820f6139a1f0914", size = 3022339, upload-time = "2025-10-15T23:17:40.888Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/30/640f34ccd4d2a1bc88367b54b926b781b5a018d65f404d409aba76a84b1c/cryptography-46.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:760f83faa07f8b64e9c33fc963d790a2edb24efb479e3520c14a45741cd9b2db", size = 3494315, upload-time = "2025-10-15T23:17:42.769Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/8b/88cc7e3bd0a8e7b861f26981f7b820e1f46aa9d26cc482d0feba0ecb4919/cryptography-46.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:516ea134e703e9fe26bcd1277a4b59ad30586ea90c365a87781d7887a646fe21", size = 2919331, upload-time = "2025-10-15T23:17:44.468Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/23/45fe7f376a7df8daf6da3556603b36f53475a99ce4faacb6ba2cf3d82021/cryptography-46.0.3-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:cb3d760a6117f621261d662bccc8ef5bc32ca673e037c83fbe565324f5c46936", size = 7218248, upload-time = "2025-10-15T23:17:46.294Z" },
-    { url = "https://files.pythonhosted.org/packages/27/32/b68d27471372737054cbd34c84981f9edbc24fe67ca225d389799614e27f/cryptography-46.0.3-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4b7387121ac7d15e550f5cb4a43aef2559ed759c35df7336c402bb8275ac9683", size = 4294089, upload-time = "2025-10-15T23:17:48.269Z" },
-    { url = "https://files.pythonhosted.org/packages/26/42/fa8389d4478368743e24e61eea78846a0006caffaf72ea24a15159215a14/cryptography-46.0.3-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:15ab9b093e8f09daab0f2159bb7e47532596075139dd74365da52ecc9cb46c5d", size = 4440029, upload-time = "2025-10-15T23:17:49.837Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/eb/f483db0ec5ac040824f269e93dd2bd8a21ecd1027e77ad7bdf6914f2fd80/cryptography-46.0.3-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:46acf53b40ea38f9c6c229599a4a13f0d46a6c3fa9ef19fc1a124d62e338dfa0", size = 4297222, upload-time = "2025-10-15T23:17:51.357Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/cf/da9502c4e1912cb1da3807ea3618a6829bee8207456fbbeebc361ec38ba3/cryptography-46.0.3-cp38-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:10ca84c4668d066a9878890047f03546f3ae0a6b8b39b697457b7757aaf18dbc", size = 4012280, upload-time = "2025-10-15T23:17:52.964Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/8f/9adb86b93330e0df8b3dcf03eae67c33ba89958fc2e03862ef1ac2b42465/cryptography-46.0.3-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:36e627112085bb3b81b19fed209c05ce2a52ee8b15d161b7c643a7d5a88491f3", size = 4978958, upload-time = "2025-10-15T23:17:54.965Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/a0/5fa77988289c34bdb9f913f5606ecc9ada1adb5ae870bd0d1054a7021cc4/cryptography-46.0.3-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:1000713389b75c449a6e979ffc7dcc8ac90b437048766cef052d4d30b8220971", size = 4473714, upload-time = "2025-10-15T23:17:56.754Z" },
-    { url = "https://files.pythonhosted.org/packages/14/e5/fc82d72a58d41c393697aa18c9abe5ae1214ff6f2a5c18ac470f92777895/cryptography-46.0.3-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:b02cf04496f6576afffef5ddd04a0cb7d49cf6be16a9059d793a30b035f6b6ac", size = 4296970, upload-time = "2025-10-15T23:17:58.588Z" },
-    { url = "https://files.pythonhosted.org/packages/78/06/5663ed35438d0b09056973994f1aec467492b33bd31da36e468b01ec1097/cryptography-46.0.3-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:71e842ec9bc7abf543b47cf86b9a743baa95f4677d22baa4c7d5c69e49e9bc04", size = 4940236, upload-time = "2025-10-15T23:18:00.897Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/59/873633f3f2dcd8a053b8dd1d38f783043b5fce589c0f6988bf55ef57e43e/cryptography-46.0.3-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:402b58fc32614f00980b66d6e56a5b4118e6cb362ae8f3fda141ba4689bd4506", size = 4472642, upload-time = "2025-10-15T23:18:02.749Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/39/8e71f3930e40f6877737d6f69248cf74d4e34b886a3967d32f919cc50d3b/cryptography-46.0.3-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ef639cb3372f69ec44915fafcd6698b6cc78fbe0c2ea41be867f6ed612811963", size = 4423126, upload-time = "2025-10-15T23:18:04.85Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/c7/f65027c2810e14c3e7268353b1681932b87e5a48e65505d8cc17c99e36ae/cryptography-46.0.3-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3b51b8ca4f1c6453d8829e1eb7299499ca7f313900dd4d89a24b8b87c0a780d4", size = 4686573, upload-time = "2025-10-15T23:18:06.908Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/6e/1c8331ddf91ca4730ab3086a0f1be19c65510a33b5a441cb334e7a2d2560/cryptography-46.0.3-cp38-abi3-win32.whl", hash = "sha256:6276eb85ef938dc035d59b87c8a7dc559a232f954962520137529d77b18ff1df", size = 3036695, upload-time = "2025-10-15T23:18:08.672Z" },
-    { url = "https://files.pythonhosted.org/packages/90/45/b0d691df20633eff80955a0fc7695ff9051ffce8b69741444bd9ed7bd0db/cryptography-46.0.3-cp38-abi3-win_amd64.whl", hash = "sha256:416260257577718c05135c55958b674000baef9a1c7d9e8f306ec60d71db850f", size = 3501720, upload-time = "2025-10-15T23:18:10.632Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/cb/2da4cc83f5edb9c3257d09e1e7ab7b23f049c7962cae8d842bbef0a9cec9/cryptography-46.0.3-cp38-abi3-win_arm64.whl", hash = "sha256:d89c3468de4cdc4f08a57e214384d0471911a3830fcdaf7a8cc587e42a866372", size = 2918740, upload-time = "2025-10-15T23:18:12.277Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/cd/1a8633802d766a0fa46f382a77e096d7e209e0817892929655fe0586ae32/cryptography-46.0.3-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a23582810fedb8c0bc47524558fb6c56aac3fc252cb306072fd2815da2a47c32", size = 3689163, upload-time = "2025-10-15T23:18:13.821Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/59/6b26512964ace6480c3e54681a9859c974172fb141c38df11eadd8416947/cryptography-46.0.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:e7aec276d68421f9574040c26e2a7c3771060bc0cff408bae1dcb19d3ab1e63c", size = 3429474, upload-time = "2025-10-15T23:18:15.477Z" },
-    { url = "https://files.pythonhosted.org/packages/06/8a/e60e46adab4362a682cf142c7dcb5bf79b782ab2199b0dcb81f55970807f/cryptography-46.0.3-pp311-pypy311_pp73-macosx_10_9_x86_64.whl", hash = "sha256:7ce938a99998ed3c8aa7e7272dca1a610401ede816d36d0693907d863b10d9ea", size = 3698132, upload-time = "2025-10-15T23:18:17.056Z" },
-    { url = "https://files.pythonhosted.org/packages/da/38/f59940ec4ee91e93d3311f7532671a5cef5570eb04a144bf203b58552d11/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:191bb60a7be5e6f54e30ba16fdfae78ad3a342a0599eb4193ba88e3f3d6e185b", size = 4243992, upload-time = "2025-10-15T23:18:18.695Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/0c/35b3d92ddebfdfda76bb485738306545817253d0a3ded0bfe80ef8e67aa5/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:c70cc23f12726be8f8bc72e41d5065d77e4515efae3690326764ea1b07845cfb", size = 4409944, upload-time = "2025-10-15T23:18:20.597Z" },
-    { url = "https://files.pythonhosted.org/packages/99/55/181022996c4063fc0e7666a47049a1ca705abb9c8a13830f074edb347495/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:9394673a9f4de09e28b5356e7fff97d778f8abad85c9d5ac4a4b7e25a0de7717", size = 4242957, upload-time = "2025-10-15T23:18:22.18Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/af/72cd6ef29f9c5f731251acadaeb821559fe25f10852f44a63374c9ca08c1/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:94cd0549accc38d1494e1f8de71eca837d0509d0d44bf11d158524b0e12cebf9", size = 4409447, upload-time = "2025-10-15T23:18:24.209Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/c3/e90f4a4feae6410f914f8ebac129b9ae7a8c92eb60a638012dde42030a9d/cryptography-46.0.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:6b5063083824e5509fdba180721d55909ffacccc8adbec85268b48439423d78c", size = 3438528, upload-time = "2025-10-15T23:18:26.227Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/81/b0bb27f2ba931a65409c6b8a8b358a7f03c0e46eceacddff55f7c84b1f3b/cryptography-46.0.5-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:351695ada9ea9618b3500b490ad54c739860883df6c1f555e088eaf25b1bbaad", size = 7176289, upload-time = "2026-02-10T19:17:08.274Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/9e/6b4397a3e3d15123de3b1806ef342522393d50736c13b20ec4c9ea6693a6/cryptography-46.0.5-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c18ff11e86df2e28854939acde2d003f7984f721eba450b56a200ad90eeb0e6b", size = 4275637, upload-time = "2026-02-10T19:17:10.53Z" },
+    { url = "https://files.pythonhosted.org/packages/63/e7/471ab61099a3920b0c77852ea3f0ea611c9702f651600397ac567848b897/cryptography-46.0.5-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4d7e3d356b8cd4ea5aff04f129d5f66ebdc7b6f8eae802b93739ed520c47c79b", size = 4424742, upload-time = "2026-02-10T19:17:12.388Z" },
+    { url = "https://files.pythonhosted.org/packages/37/53/a18500f270342d66bf7e4d9f091114e31e5ee9e7375a5aba2e85a91e0044/cryptography-46.0.5-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:50bfb6925eff619c9c023b967d5b77a54e04256c4281b0e21336a130cd7fc263", size = 4277528, upload-time = "2026-02-10T19:17:13.853Z" },
+    { url = "https://files.pythonhosted.org/packages/22/29/c2e812ebc38c57b40e7c583895e73c8c5adb4d1e4a0cc4c5a4fdab2b1acc/cryptography-46.0.5-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:803812e111e75d1aa73690d2facc295eaefd4439be1023fefc4995eaea2af90d", size = 4947993, upload-time = "2026-02-10T19:17:15.618Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/e7/237155ae19a9023de7e30ec64e5d99a9431a567407ac21170a046d22a5a3/cryptography-46.0.5-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3ee190460e2fbe447175cda91b88b84ae8322a104fc27766ad09428754a618ed", size = 4456855, upload-time = "2026-02-10T19:17:17.221Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/87/fc628a7ad85b81206738abbd213b07702bcbdada1dd43f72236ef3cffbb5/cryptography-46.0.5-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:f145bba11b878005c496e93e257c1e88f154d278d2638e6450d17e0f31e558d2", size = 3984635, upload-time = "2026-02-10T19:17:18.792Z" },
+    { url = "https://files.pythonhosted.org/packages/84/29/65b55622bde135aedf4565dc509d99b560ee4095e56989e815f8fd2aa910/cryptography-46.0.5-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:e9251e3be159d1020c4030bd2e5f84d6a43fe54b6c19c12f51cde9542a2817b2", size = 4277038, upload-time = "2026-02-10T19:17:20.256Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/36/45e76c68d7311432741faf1fbf7fac8a196a0a735ca21f504c75d37e2558/cryptography-46.0.5-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:47fb8a66058b80e509c47118ef8a75d14c455e81ac369050f20ba0d23e77fee0", size = 4912181, upload-time = "2026-02-10T19:17:21.825Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/1a/c1ba8fead184d6e3d5afcf03d569acac5ad063f3ac9fb7258af158f7e378/cryptography-46.0.5-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:4c3341037c136030cb46e4b1e17b7418ea4cbd9dd207e4a6f3b2b24e0d4ac731", size = 4456482, upload-time = "2026-02-10T19:17:25.133Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/e5/3fb22e37f66827ced3b902cf895e6a6bc1d095b5b26be26bd13c441fdf19/cryptography-46.0.5-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:890bcb4abd5a2d3f852196437129eb3667d62630333aacc13dfd470fad3aaa82", size = 4405497, upload-time = "2026-02-10T19:17:26.66Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/df/9d58bb32b1121a8a2f27383fabae4d63080c7ca60b9b5c88be742be04ee7/cryptography-46.0.5-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:80a8d7bfdf38f87ca30a5391c0c9ce4ed2926918e017c29ddf643d0ed2778ea1", size = 4667819, upload-time = "2026-02-10T19:17:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/ed/325d2a490c5e94038cdb0117da9397ece1f11201f425c4e9c57fe5b9f08b/cryptography-46.0.5-cp311-abi3-win32.whl", hash = "sha256:60ee7e19e95104d4c03871d7d7dfb3d22ef8a9b9c6778c94e1c8fcc8365afd48", size = 3028230, upload-time = "2026-02-10T19:17:30.518Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/5a/ac0f49e48063ab4255d9e3b79f5def51697fce1a95ea1370f03dc9db76f6/cryptography-46.0.5-cp311-abi3-win_amd64.whl", hash = "sha256:38946c54b16c885c72c4f59846be9743d699eee2b69b6988e0a00a01f46a61a4", size = 3480909, upload-time = "2026-02-10T19:17:32.083Z" },
+    { url = "https://files.pythonhosted.org/packages/00/13/3d278bfa7a15a96b9dc22db5a12ad1e48a9eb3d40e1827ef66a5df75d0d0/cryptography-46.0.5-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:94a76daa32eb78d61339aff7952ea819b1734b46f73646a07decb40e5b3448e2", size = 7119287, upload-time = "2026-02-10T19:17:33.801Z" },
+    { url = "https://files.pythonhosted.org/packages/67/c8/581a6702e14f0898a0848105cbefd20c058099e2c2d22ef4e476dfec75d7/cryptography-46.0.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5be7bf2fb40769e05739dd0046e7b26f9d4670badc7b032d6ce4db64dddc0678", size = 4265728, upload-time = "2026-02-10T19:17:35.569Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/4a/ba1a65ce8fc65435e5a849558379896c957870dd64fecea97b1ad5f46a37/cryptography-46.0.5-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fe346b143ff9685e40192a4960938545c699054ba11d4f9029f94751e3f71d87", size = 4408287, upload-time = "2026-02-10T19:17:36.938Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/67/8ffdbf7b65ed1ac224d1c2df3943553766914a8ca718747ee3871da6107e/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:c69fd885df7d089548a42d5ec05be26050ebcd2283d89b3d30676eb32ff87dee", size = 4270291, upload-time = "2026-02-10T19:17:38.748Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/e5/f52377ee93bc2f2bba55a41a886fd208c15276ffbd2569f2ddc89d50e2c5/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:8293f3dea7fc929ef7240796ba231413afa7b68ce38fd21da2995549f5961981", size = 4927539, upload-time = "2026-02-10T19:17:40.241Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/02/cfe39181b02419bbbbcf3abdd16c1c5c8541f03ca8bda240debc467d5a12/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:1abfdb89b41c3be0365328a410baa9df3ff8a9110fb75e7b52e66803ddabc9a9", size = 4442199, upload-time = "2026-02-10T19:17:41.789Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/96/2fcaeb4873e536cf71421a388a6c11b5bc846e986b2b069c79363dc1648e/cryptography-46.0.5-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:d66e421495fdb797610a08f43b05269e0a5ea7f5e652a89bfd5a7d3c1dee3648", size = 3960131, upload-time = "2026-02-10T19:17:43.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/d2/b27631f401ddd644e94c5cf33c9a4069f72011821cf3dc7309546b0642a0/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:4e817a8920bfbcff8940ecfd60f23d01836408242b30f1a708d93198393a80b4", size = 4270072, upload-time = "2026-02-10T19:17:45.481Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/a7/60d32b0370dae0b4ebe55ffa10e8599a2a59935b5ece1b9f06edb73abdeb/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:68f68d13f2e1cb95163fa3b4db4bf9a159a418f5f6e7242564fc75fcae667fd0", size = 4892170, upload-time = "2026-02-10T19:17:46.997Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/b9/cf73ddf8ef1164330eb0b199a589103c363afa0cf794218c24d524a58eab/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:a3d1fae9863299076f05cb8a778c467578262fae09f9dc0ee9b12eb4268ce663", size = 4441741, upload-time = "2026-02-10T19:17:48.661Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/eb/eee00b28c84c726fe8fa0158c65afe312d9c3b78d9d01daf700f1f6e37ff/cryptography-46.0.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4143987a42a2397f2fc3b4d7e3a7d313fbe684f67ff443999e803dd75a76826", size = 4396728, upload-time = "2026-02-10T19:17:50.058Z" },
+    { url = "https://files.pythonhosted.org/packages/65/f4/6bc1a9ed5aef7145045114b75b77c2a8261b4d38717bd8dea111a63c3442/cryptography-46.0.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:7d731d4b107030987fd61a7f8ab512b25b53cef8f233a97379ede116f30eb67d", size = 4652001, upload-time = "2026-02-10T19:17:51.54Z" },
+    { url = "https://files.pythonhosted.org/packages/86/ef/5d00ef966ddd71ac2e6951d278884a84a40ffbd88948ef0e294b214ae9e4/cryptography-46.0.5-cp314-cp314t-win32.whl", hash = "sha256:c3bcce8521d785d510b2aad26ae2c966092b7daa8f45dd8f44734a104dc0bc1a", size = 3003637, upload-time = "2026-02-10T19:17:52.997Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/57/f3f4160123da6d098db78350fdfd9705057aad21de7388eacb2401dceab9/cryptography-46.0.5-cp314-cp314t-win_amd64.whl", hash = "sha256:4d8ae8659ab18c65ced284993c2265910f6c9e650189d4e3f68445ef82a810e4", size = 3469487, upload-time = "2026-02-10T19:17:54.549Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/fa/a66aa722105ad6a458bebd64086ca2b72cdd361fed31763d20390f6f1389/cryptography-46.0.5-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:4108d4c09fbbf2789d0c926eb4152ae1760d5a2d97612b92d508d96c861e4d31", size = 7170514, upload-time = "2026-02-10T19:17:56.267Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/04/c85bdeab78c8bc77b701bf0d9bdcf514c044e18a46dcff330df5448631b0/cryptography-46.0.5-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7d1f30a86d2757199cb2d56e48cce14deddf1f9c95f1ef1b64ee91ea43fe2e18", size = 4275349, upload-time = "2026-02-10T19:17:58.419Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/32/9b87132a2f91ee7f5223b091dc963055503e9b442c98fc0b8a5ca765fab0/cryptography-46.0.5-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:039917b0dc418bb9f6edce8a906572d69e74bd330b0b3fea4f79dab7f8ddd235", size = 4420667, upload-time = "2026-02-10T19:18:00.619Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/a6/a7cb7010bec4b7c5692ca6f024150371b295ee1c108bdc1c400e4c44562b/cryptography-46.0.5-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:ba2a27ff02f48193fc4daeadf8ad2590516fa3d0adeeb34336b96f7fa64c1e3a", size = 4276980, upload-time = "2026-02-10T19:18:02.379Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/7c/c4f45e0eeff9b91e3f12dbd0e165fcf2a38847288fcfd889deea99fb7b6d/cryptography-46.0.5-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:61aa400dce22cb001a98014f647dc21cda08f7915ceb95df0c9eaf84b4b6af76", size = 4939143, upload-time = "2026-02-10T19:18:03.964Z" },
+    { url = "https://files.pythonhosted.org/packages/37/19/e1b8f964a834eddb44fa1b9a9976f4e414cbb7aa62809b6760c8803d22d1/cryptography-46.0.5-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3ce58ba46e1bc2aac4f7d9290223cead56743fa6ab94a5d53292ffaac6a91614", size = 4453674, upload-time = "2026-02-10T19:18:05.588Z" },
+    { url = "https://files.pythonhosted.org/packages/db/ed/db15d3956f65264ca204625597c410d420e26530c4e2943e05a0d2f24d51/cryptography-46.0.5-cp38-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:420d0e909050490d04359e7fdb5ed7e667ca5c3c402b809ae2563d7e66a92229", size = 3978801, upload-time = "2026-02-10T19:18:07.167Z" },
+    { url = "https://files.pythonhosted.org/packages/41/e2/df40a31d82df0a70a0daf69791f91dbb70e47644c58581d654879b382d11/cryptography-46.0.5-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:582f5fcd2afa31622f317f80426a027f30dc792e9c80ffee87b993200ea115f1", size = 4276755, upload-time = "2026-02-10T19:18:09.813Z" },
+    { url = "https://files.pythonhosted.org/packages/33/45/726809d1176959f4a896b86907b98ff4391a8aa29c0aaaf9450a8a10630e/cryptography-46.0.5-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:bfd56bb4b37ed4f330b82402f6f435845a5f5648edf1ad497da51a8452d5d62d", size = 4901539, upload-time = "2026-02-10T19:18:11.263Z" },
+    { url = "https://files.pythonhosted.org/packages/99/0f/a3076874e9c88ecb2ecc31382f6e7c21b428ede6f55aafa1aa272613e3cd/cryptography-46.0.5-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:a3d507bb6a513ca96ba84443226af944b0f7f47dcc9a399d110cd6146481d24c", size = 4452794, upload-time = "2026-02-10T19:18:12.914Z" },
+    { url = "https://files.pythonhosted.org/packages/02/ef/ffeb542d3683d24194a38f66ca17c0a4b8bf10631feef44a7ef64e631b1a/cryptography-46.0.5-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9f16fbdf4da055efb21c22d81b89f155f02ba420558db21288b3d0035bafd5f4", size = 4404160, upload-time = "2026-02-10T19:18:14.375Z" },
+    { url = "https://files.pythonhosted.org/packages/96/93/682d2b43c1d5f1406ed048f377c0fc9fc8f7b0447a478d5c65ab3d3a66eb/cryptography-46.0.5-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ced80795227d70549a411a4ab66e8ce307899fad2220ce5ab2f296e687eacde9", size = 4667123, upload-time = "2026-02-10T19:18:15.886Z" },
+    { url = "https://files.pythonhosted.org/packages/45/2d/9c5f2926cb5300a8eefc3f4f0b3f3df39db7f7ce40c8365444c49363cbda/cryptography-46.0.5-cp38-abi3-win32.whl", hash = "sha256:02f547fce831f5096c9a567fd41bc12ca8f11df260959ecc7c3202555cc47a72", size = 3010220, upload-time = "2026-02-10T19:18:17.361Z" },
+    { url = "https://files.pythonhosted.org/packages/48/ef/0c2f4a8e31018a986949d34a01115dd057bf536905dca38897bacd21fac3/cryptography-46.0.5-cp38-abi3-win_amd64.whl", hash = "sha256:556e106ee01aa13484ce9b0239bca667be5004efb0aabbed28d353df86445595", size = 3467050, upload-time = "2026-02-10T19:18:18.899Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/dd/2d9fdb07cebdf3d51179730afb7d5e576153c6744c3ff8fded23030c204e/cryptography-46.0.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:3b4995dc971c9fb83c25aa44cf45f02ba86f71ee600d81091c2f0cbae116b06c", size = 3476964, upload-time = "2026-02-10T19:18:20.687Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/6f/6cc6cc9955caa6eaf83660b0da2b077c7fe8ff9950a3c5e45d605038d439/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:bc84e875994c3b445871ea7181d424588171efec3e185dced958dad9e001950a", size = 4218321, upload-time = "2026-02-10T19:18:22.349Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/5d/c4da701939eeee699566a6c1367427ab91a8b7088cc2328c09dbee940415/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:2ae6971afd6246710480e3f15824ed3029a60fc16991db250034efd0b9fb4356", size = 4381786, upload-time = "2026-02-10T19:18:24.529Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/97/a538654732974a94ff96c1db621fa464f455c02d4bb7d2652f4edc21d600/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:d861ee9e76ace6cf36a6a89b959ec08e7bc2493ee39d07ffe5acb23ef46d27da", size = 4217990, upload-time = "2026-02-10T19:18:25.957Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/11/7e500d2dd3ba891197b9efd2da5454b74336d64a7cc419aa7327ab74e5f6/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:2b7a67c9cd56372f3249b39699f2ad479f6991e62ea15800973b956f4b73e257", size = 4381252, upload-time = "2026-02-10T19:18:27.496Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/58/6b3d24e6b9bc474a2dcdee65dfd1f008867015408a271562e4b690561a4d/cryptography-46.0.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:8456928655f856c6e1533ff59d5be76578a7157224dbd9ce6872f25055ab9ab7", size = 3407605, upload-time = "2026-02-10T19:18:29.233Z" },
 ]
 
 [[package]]
@@ -1353,7 +1348,7 @@ wheels = [
 
 [[package]]
 name = "langchain-core"
-version = "1.2.7"
+version = "1.2.13"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jsonpatch" },
@@ -1365,9 +1360,9 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "uuid-utils" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a2/0e/664d8d81b3493e09cbab72448d2f9d693d1fa5aa2bcc488602203a9b6da0/langchain_core-1.2.7.tar.gz", hash = "sha256:e1460639f96c352b4a41c375f25aeb8d16ffc1769499fb1c20503aad59305ced", size = 837039, upload-time = "2026-01-09T17:44:25.505Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fb/bb/c501ca60556c11ac80d1454bdcac63cb33583ce4e64fc4535ad5a7d5c6ba/langchain_core-1.2.13.tar.gz", hash = "sha256:d2773d0d0130a356378db9a858cfeef64c3d64bc03722f1d4d6c40eb46fdf01b", size = 831612, upload-time = "2026-02-15T07:45:57.014Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6e/6f/34a9fba14d191a67f7e2ee3dbce3e9b86d2fa7310e2c7f2c713583481bd2/langchain_core-1.2.7-py3-none-any.whl", hash = "sha256:452f4fef7a3d883357b22600788d37e3d8854ef29da345b7ac7099f33c31828b", size = 490232, upload-time = "2026-01-09T17:44:24.236Z" },
+    { url = "https://files.pythonhosted.org/packages/12/ab/60fd69e5d55f67d422baefddaaca523c42cd7510ab6aeb17db6ae57fb107/langchain_core-1.2.13-py3-none-any.whl", hash = "sha256:b31823e28d3eff1e237096d0bd3bf80c6f9624eb471a9496dbfbd427779f8d82", size = 500485, upload-time = "2026-02-15T07:45:55.422Z" },
 ]
 
 [[package]]
@@ -1480,7 +1475,7 @@ dev = [
     { name = "ruff" },
     { name = "syrupy" },
     { name = "types-requests" },
-    { name = "uvloop", specifier = "==0.21.0b1" },
+    { name = "uvloop", specifier = "==0.22.1" },
 ]
 lint = [
     { name = "mypy" },
@@ -1510,7 +1505,7 @@ test = [
     { name = "pytest-xdist", extras = ["psutil"] },
     { name = "redis" },
     { name = "syrupy" },
-    { name = "uvloop", specifier = "==0.21.0b1" },
+    { name = "uvloop", specifier = "==0.22.1" },
 ]
 
 [[package]]
@@ -1824,22 +1819,22 @@ requires-dist = [
 dev = [
     { name = "codespell" },
     { name = "langgraph", editable = "." },
-    { name = "mypy", specifier = "==1.19.0" },
+    { name = "mypy", specifier = "==1.19.1" },
     { name = "pydantic", specifier = ">=2.12.4" },
     { name = "pytest" },
     { name = "pytest-asyncio" },
     { name = "pytest-mock" },
     { name = "pytest-watch" },
-    { name = "ruff", specifier = "==0.14.11" },
+    { name = "ruff", specifier = "==0.15.1" },
     { name = "starlette" },
-    { name = "ty", specifier = "==0.0.1a27" },
+    { name = "ty", specifier = "==0.0.17" },
 ]
 lint = [
     { name = "codespell" },
-    { name = "mypy", specifier = "==1.19.0" },
-    { name = "ruff", specifier = "==0.14.11" },
+    { name = "mypy", specifier = "==1.19.1" },
+    { name = "ruff", specifier = "==0.15.1" },
     { name = "starlette" },
-    { name = "ty", specifier = "==0.0.1a27" },
+    { name = "ty", specifier = "==0.0.17" },
 ]
 test = [
     { name = "pytest" },
@@ -2137,7 +2132,7 @@ wheels = [
 
 [[package]]
 name = "nbconvert"
-version = "7.16.6"
+version = "7.17.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "beautifulsoup4" },
@@ -2155,9 +2150,9 @@ dependencies = [
     { name = "pygments" },
     { name = "traitlets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a3/59/f28e15fc47ffb73af68a8d9b47367a8630d76e97ae85ad18271b9db96fdf/nbconvert-7.16.6.tar.gz", hash = "sha256:576a7e37c6480da7b8465eefa66c17844243816ce1ccc372633c6b71c3c0f582", size = 857715, upload-time = "2025-01-28T09:29:14.724Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/38/47/81f886b699450d0569f7bc551df2b1673d18df7ff25cc0c21ca36ed8a5ff/nbconvert-7.17.0.tar.gz", hash = "sha256:1b2696f1b5be12309f6c7d707c24af604b87dfaf6d950794c7b07acab96dda78", size = 862855, upload-time = "2026-01-29T16:37:48.478Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/cc/9a/cd673b2f773a12c992f41309ef81b99da1690426bd2f96957a7ade0d3ed7/nbconvert-7.16.6-py3-none-any.whl", hash = "sha256:1375a7b67e0c2883678c48e506dc320febb57685e5ee67faa51b18a90f3a712b", size = 258525, upload-time = "2025-01-28T09:29:12.551Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/4b/8d5f796a792f8a25f6925a96032f098789f448571eb92011df1ae59e8ea8/nbconvert-7.17.0-py3-none-any.whl", hash = "sha256:4f99a63b337b9a23504347afdab24a11faa7d86b405e5c8f9881cd313336d518", size = 261510, upload-time = "2026-01-29T16:37:46.322Z" },
 ]
 
 [[package]]
@@ -2528,17 +2523,17 @@ wheels = [
 
 [[package]]
 name = "protobuf"
-version = "6.33.4"
+version = "6.33.5"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/53/b8/cda15d9d46d03d4aa3a67cb6bffe05173440ccf86a9541afaf7ac59a1b6b/protobuf-6.33.4.tar.gz", hash = "sha256:dc2e61bca3b10470c1912d166fe0af67bfc20eb55971dcef8dfa48ce14f0ed91", size = 444346, upload-time = "2026-01-12T18:33:40.109Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ba/25/7c72c307aafc96fa87062aa6291d9f7c94836e43214d43722e86037aac02/protobuf-6.33.5.tar.gz", hash = "sha256:6ddcac2a081f8b7b9642c09406bc6a4290128fce5f471cddd165960bb9119e5c", size = 444465, upload-time = "2026-01-29T21:51:33.494Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e0/be/24ef9f3095bacdf95b458543334d0c4908ccdaee5130420bf064492c325f/protobuf-6.33.4-cp310-abi3-win32.whl", hash = "sha256:918966612c8232fc6c24c78e1cd89784307f5814ad7506c308ee3cf86662850d", size = 425612, upload-time = "2026-01-12T18:33:29.656Z" },
-    { url = "https://files.pythonhosted.org/packages/31/ad/e5693e1974a28869e7cd244302911955c1cebc0161eb32dfa2b25b6e96f0/protobuf-6.33.4-cp310-abi3-win_amd64.whl", hash = "sha256:8f11ffae31ec67fc2554c2ef891dcb561dae9a2a3ed941f9e134c2db06657dbc", size = 436962, upload-time = "2026-01-12T18:33:31.345Z" },
-    { url = "https://files.pythonhosted.org/packages/66/15/6ee23553b6bfd82670207ead921f4d8ef14c107e5e11443b04caeb5ab5ec/protobuf-6.33.4-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:2fe67f6c014c84f655ee06f6f66213f9254b3a8b6bda6cda0ccd4232c73c06f0", size = 427612, upload-time = "2026-01-12T18:33:32.646Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/48/d301907ce6d0db75f959ca74f44b475a9caa8fcba102d098d3c3dd0f2d3f/protobuf-6.33.4-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:757c978f82e74d75cba88eddec479df9b99a42b31193313b75e492c06a51764e", size = 324484, upload-time = "2026-01-12T18:33:33.789Z" },
-    { url = "https://files.pythonhosted.org/packages/92/1c/e53078d3f7fe710572ab2dcffd993e1e3b438ae71cfc031b71bae44fcb2d/protobuf-6.33.4-cp39-abi3-manylinux2014_s390x.whl", hash = "sha256:c7c64f259c618f0bef7bee042075e390debbf9682334be2b67408ec7c1c09ee6", size = 339256, upload-time = "2026-01-12T18:33:35.231Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/8e/971c0edd084914f7ee7c23aa70ba89e8903918adca179319ee94403701d5/protobuf-6.33.4-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:3df850c2f8db9934de4cf8f9152f8dc2558f49f298f37f90c517e8e5c84c30e9", size = 323311, upload-time = "2026-01-12T18:33:36.305Z" },
-    { url = "https://files.pythonhosted.org/packages/75/b1/1dc83c2c661b4c62d56cc081706ee33a4fc2835bd90f965baa2663ef7676/protobuf-6.33.4-py3-none-any.whl", hash = "sha256:1fe3730068fcf2e595816a6c34fe66eeedd37d51d0400b72fabc848811fdc1bc", size = 170532, upload-time = "2026-01-12T18:33:39.199Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/79/af92d0a8369732b027e6d6084251dd8e782c685c72da161bd4a2e00fbabb/protobuf-6.33.5-cp310-abi3-win32.whl", hash = "sha256:d71b040839446bac0f4d162e758bea99c8251161dae9d0983a3b88dee345153b", size = 425769, upload-time = "2026-01-29T21:51:21.751Z" },
+    { url = "https://files.pythonhosted.org/packages/55/75/bb9bc917d10e9ee13dee8607eb9ab963b7cf8be607c46e7862c748aa2af7/protobuf-6.33.5-cp310-abi3-win_amd64.whl", hash = "sha256:3093804752167bcab3998bec9f1048baae6e29505adaf1afd14a37bddede533c", size = 437118, upload-time = "2026-01-29T21:51:24.022Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/6b/e48dfc1191bc5b52950246275bf4089773e91cb5ba3592621723cdddca62/protobuf-6.33.5-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:a5cb85982d95d906df1e2210e58f8e4f1e3cdc088e52c921a041f9c9a0386de5", size = 427766, upload-time = "2026-01-29T21:51:25.413Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/b1/c79468184310de09d75095ed1314b839eb2f72df71097db9d1404a1b2717/protobuf-6.33.5-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:9b71e0281f36f179d00cbcb119cb19dec4d14a81393e5ea220f64b286173e190", size = 324638, upload-time = "2026-01-29T21:51:26.423Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/f5/65d838092fd01c44d16037953fd4c2cc851e783de9b8f02b27ec4ffd906f/protobuf-6.33.5-cp39-abi3-manylinux2014_s390x.whl", hash = "sha256:8afa18e1d6d20af15b417e728e9f60f3aa108ee76f23c3b2c07a2c3b546d3afd", size = 339411, upload-time = "2026-01-29T21:51:27.446Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/53/a9443aa3ca9ba8724fdfa02dd1887c1bcd8e89556b715cfbacca6b63dbec/protobuf-6.33.5-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:cbf16ba3350fb7b889fca858fb215967792dc125b35c7976ca4818bee3521cf0", size = 323465, upload-time = "2026-01-29T21:51:28.925Z" },
+    { url = "https://files.pythonhosted.org/packages/57/bf/2086963c69bdac3d7cff1cc7ff79b8ce5ea0bec6797a017e1be338a46248/protobuf-6.33.5-py3-none-any.whl", hash = "sha256:69915a973dd0f60f31a08b8318b73eab2bd6a392c79184b3612226b0a3f8ec02", size = 170687, upload-time = "2026-01-29T21:51:32.557Z" },
 ]
 
 [[package]]
@@ -2891,14 +2886,14 @@ wheels = [
 
 [[package]]
 name = "pyperf"
-version = "2.9.0"
+version = "2.10.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "psutil" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/89/f9/27bd50fb5475147ad04e288a076f29a893c1e94f10866fc3623a84ad75d2/pyperf-2.9.0.tar.gz", hash = "sha256:dbe0feef8ec1a465df191bba2576149762d15a8c9985c9fea93ab625d875c362", size = 227189, upload-time = "2025-03-04T13:45:44.335Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/16/91/39ca77aa58f13e8c65d747ac7e06584b55acabfa98987fb8d546bc24860d/pyperf-2.10.0.tar.gz", hash = "sha256:dd93ccfda79214725293e95f1fa6e00cb4a64adcf1326039486d4e1f91caaa62", size = 227609, upload-time = "2026-02-07T11:35:14.693Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/19/29/ce5d2dcb095debb3bed0654950c45207a7d138e194abef0ded4b86de1dc1/pyperf-2.9.0-py3-none-any.whl", hash = "sha256:215673fb60f3fbbc6c7a90b609b0806d8466fded8dd502bf5731e2b92506076e", size = 144204, upload-time = "2025-03-04T13:45:40.491Z" },
+    { url = "https://files.pythonhosted.org/packages/91/26/f7bd5e37c254c2671f4dfff316d123eba13663bdfee941a01b09ab02d72d/pyperf-2.10.0-py3-none-any.whl", hash = "sha256:79196bc4a11e3c926dd4c6b14c80136c6b37f884fe913cbc57037f37636e9841", size = 144430, upload-time = "2026-02-07T11:35:12.636Z" },
 ]
 
 [[package]]
@@ -3185,14 +3180,14 @@ wheels = [
 
 [[package]]
 name = "redis"
-version = "7.1.0"
+version = "7.2.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "async-timeout", marker = "python_full_version < '3.11.3'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/43/c8/983d5c6579a411d8a99bc5823cc5712768859b5ce2c8afe1a65b37832c81/redis-7.1.0.tar.gz", hash = "sha256:b1cc3cfa5a2cb9c2ab3ba700864fb0ad75617b41f01352ce5779dabf6d5f9c3c", size = 4796669, upload-time = "2025-11-19T15:54:39.961Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/9f/32/6fac13a11e73e1bc67a2ae821a72bfe4c2d8c4c48f0267e4a952be0f1bae/redis-7.2.0.tar.gz", hash = "sha256:4dd5bf4bd4ae80510267f14185a15cba2a38666b941aff68cccf0256b51c1f26", size = 4901247, upload-time = "2026-02-16T17:16:22.797Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/89/f0/8956f8a86b20d7bb9d6ac0187cf4cd54d8065bc9a1a09eb8011d4d326596/redis-7.1.0-py3-none-any.whl", hash = "sha256:23c52b208f92b56103e17c5d06bdc1a6c2c0b3106583985a76a18f83b265de2b", size = 354159, upload-time = "2025-11-19T15:54:38.064Z" },
+    { url = "https://files.pythonhosted.org/packages/86/cf/f6180b67f99688d83e15c84c5beda831d1d341e95872d224f87ccafafe61/redis-7.2.0-py3-none-any.whl", hash = "sha256:01f591f8598e483f1842d429e8ae3a820804566f1c73dca1b80e23af9fba0497", size = 394898, upload-time = "2026-02-16T17:16:20.693Z" },
 ]
 
 [[package]]
@@ -3393,28 +3388,27 @@ wheels = [
 
 [[package]]
 name = "ruff"
-version = "0.14.13"
+version = "0.15.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/50/0a/1914efb7903174b381ee2ffeebb4253e729de57f114e63595114c8ca451f/ruff-0.14.13.tar.gz", hash = "sha256:83cd6c0763190784b99650a20fec7633c59f6ebe41c5cc9d45ee42749563ad47", size = 6059504, upload-time = "2026-01-15T20:15:16.918Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/dc/4e6ac71b511b141cf626357a3946679abeba4cf67bc7cc5a17920f31e10d/ruff-0.15.1.tar.gz", hash = "sha256:c590fe13fb57c97141ae975c03a1aedb3d3156030cabd740d6ff0b0d601e203f", size = 4540855, upload-time = "2026-02-12T23:09:09.998Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c3/ae/0deefbc65ca74b0ab1fd3917f94dc3b398233346a74b8bbb0a916a1a6bf6/ruff-0.14.13-py3-none-linux_armv6l.whl", hash = "sha256:76f62c62cd37c276cb03a275b198c7c15bd1d60c989f944db08a8c1c2dbec18b", size = 13062418, upload-time = "2026-01-15T20:14:50.779Z" },
-    { url = "https://files.pythonhosted.org/packages/47/df/5916604faa530a97a3c154c62a81cb6b735c0cb05d1e26d5ad0f0c8ac48a/ruff-0.14.13-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:914a8023ece0528d5cc33f5a684f5f38199bbb566a04815c2c211d8f40b5d0ed", size = 13442344, upload-time = "2026-01-15T20:15:07.94Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/f3/e0e694dd69163c3a1671e102aa574a50357536f18a33375050334d5cd517/ruff-0.14.13-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d24899478c35ebfa730597a4a775d430ad0d5631b8647a3ab368c29b7e7bd063", size = 12354720, upload-time = "2026-01-15T20:15:09.854Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/e8/67f5fcbbaee25e8fc3b56cc33e9892eca7ffe09f773c8e5907757a7e3bdb/ruff-0.14.13-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9aaf3870f14d925bbaf18b8a2347ee0ae7d95a2e490e4d4aea6813ed15ebc80e", size = 12774493, upload-time = "2026-01-15T20:15:20.908Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/ce/d2e9cb510870b52a9565d885c0d7668cc050e30fa2c8ac3fb1fda15c083d/ruff-0.14.13-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac5b7f63dd3b27cc811850f5ffd8fff845b00ad70e60b043aabf8d6ecc304e09", size = 12815174, upload-time = "2026-01-15T20:15:05.74Z" },
-    { url = "https://files.pythonhosted.org/packages/88/00/c38e5da58beebcf4fa32d0ddd993b63dfacefd02ab7922614231330845bf/ruff-0.14.13-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:78d2b1097750d90ba82ce4ba676e85230a0ed694178ca5e61aa9b459970b3eb9", size = 13680909, upload-time = "2026-01-15T20:15:14.537Z" },
-    { url = "https://files.pythonhosted.org/packages/61/61/cd37c9dd5bd0a3099ba79b2a5899ad417d8f3b04038810b0501a80814fd7/ruff-0.14.13-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:7d0bf87705acbbcb8d4c24b2d77fbb73d40210a95c3903b443cd9e30824a5032", size = 15144215, upload-time = "2026-01-15T20:15:22.886Z" },
-    { url = "https://files.pythonhosted.org/packages/56/8a/85502d7edbf98c2df7b8876f316c0157359165e16cdf98507c65c8d07d3d/ruff-0.14.13-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a3eb5da8e2c9e9f13431032fdcbe7681de9ceda5835efee3269417c13f1fed5c", size = 14706067, upload-time = "2026-01-15T20:14:48.271Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/2f/de0df127feb2ee8c1e54354dc1179b4a23798f0866019528c938ba439aca/ruff-0.14.13-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:642442b42957093811cd8d2140dfadd19c7417030a7a68cf8d51fcdd5f217427", size = 14133916, upload-time = "2026-01-15T20:14:57.357Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/77/9b99686bb9fe07a757c82f6f95e555c7a47801a9305576a9c67e0a31d280/ruff-0.14.13-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4acdf009f32b46f6e8864af19cbf6841eaaed8638e65c8dac845aea0d703c841", size = 13859207, upload-time = "2026-01-15T20:14:55.111Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/46/2bdcb34a87a179a4d23022d818c1c236cb40e477faf0d7c9afb6813e5876/ruff-0.14.13-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:591a7f68860ea4e003917d19b5c4f5ac39ff558f162dc753a2c5de897fd5502c", size = 14043686, upload-time = "2026-01-15T20:14:52.841Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/a9/5c6a4f56a0512c691cf143371bcf60505ed0f0860f24a85da8bd123b2bf1/ruff-0.14.13-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:774c77e841cc6e046fc3e91623ce0903d1cd07e3a36b1a9fe79b81dab3de506b", size = 12663837, upload-time = "2026-01-15T20:15:18.921Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/bb/b920016ece7651fa7fcd335d9d199306665486694d4361547ccb19394c44/ruff-0.14.13-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:61f4e40077a1248436772bb6512db5fc4457fe4c49e7a94ea7c5088655dd21ae", size = 12805867, upload-time = "2026-01-15T20:14:59.272Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/b3/0bd909851e5696cd21e32a8fc25727e5f58f1934b3596975503e6e85415c/ruff-0.14.13-py3-none-musllinux_1_2_i686.whl", hash = "sha256:6d02f1428357fae9e98ac7aa94b7e966fd24151088510d32cf6f902d6c09235e", size = 13208528, upload-time = "2026-01-15T20:15:03.732Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/3b/e2d94cb613f6bbd5155a75cbe072813756363eba46a3f2177a1fcd0cd670/ruff-0.14.13-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e399341472ce15237be0c0ae5fbceca4b04cd9bebab1a2b2c979e015455d8f0c", size = 13929242, upload-time = "2026-01-15T20:15:11.918Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/c5/abd840d4132fd51a12f594934af5eba1d5d27298a6f5b5d6c3be45301caf/ruff-0.14.13-py3-none-win32.whl", hash = "sha256:ef720f529aec113968b45dfdb838ac8934e519711da53a0456038a0efecbd680", size = 12919024, upload-time = "2026-01-15T20:14:43.647Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/55/6384b0b8ce731b6e2ade2b5449bf07c0e4c31e8a2e68ea65b3bafadcecc5/ruff-0.14.13-py3-none-win_amd64.whl", hash = "sha256:6070bd026e409734b9257e03e3ef18c6e1a216f0435c6751d7a8ec69cb59abef", size = 14097887, upload-time = "2026-01-15T20:15:01.48Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/e1/7348090988095e4e39560cfc2f7555b1b2a7357deba19167b600fdf5215d/ruff-0.14.13-py3-none-win_arm64.whl", hash = "sha256:7ab819e14f1ad9fe39f246cfcc435880ef7a9390d81a2b6ac7e01039083dd247", size = 13080224, upload-time = "2026-01-15T20:14:45.853Z" },
+    { url = "https://files.pythonhosted.org/packages/23/bf/e6e4324238c17f9d9120a9d60aa99a7daaa21204c07fcd84e2ef03bb5fd1/ruff-0.15.1-py3-none-linux_armv6l.whl", hash = "sha256:b101ed7cf4615bda6ffe65bdb59f964e9f4a0d3f85cbf0e54f0ab76d7b90228a", size = 10367819, upload-time = "2026-02-12T23:09:03.598Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/ea/c8f89d32e7912269d38c58f3649e453ac32c528f93bb7f4219258be2e7ed/ruff-0.15.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:939c995e9277e63ea632cc8d3fae17aa758526f49a9a850d2e7e758bfef46602", size = 10798618, upload-time = "2026-02-12T23:09:22.928Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/0f/1d0d88bc862624247d82c20c10d4c0f6bb2f346559d8af281674cf327f15/ruff-0.15.1-py3-none-macosx_11_0_arm64.whl", hash = "sha256:1d83466455fdefe60b8d9c8df81d3c1bbb2115cede53549d3b522ce2bc703899", size = 10148518, upload-time = "2026-02-12T23:08:58.339Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/c8/291c49cefaa4a9248e986256df2ade7add79388fe179e0691be06fae6f37/ruff-0.15.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9457e3c3291024866222b96108ab2d8265b477e5b1534c7ddb1810904858d16", size = 10518811, upload-time = "2026-02-12T23:09:31.865Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/1a/f5707440e5ae43ffa5365cac8bbb91e9665f4a883f560893829cf16a606b/ruff-0.15.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:92c92b003e9d4f7fbd33b1867bb15a1b785b1735069108dfc23821ba045b29bc", size = 10196169, upload-time = "2026-02-12T23:09:17.306Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/ff/26ddc8c4da04c8fd3ee65a89c9fb99eaa5c30394269d424461467be2271f/ruff-0.15.1-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fe5c41ab43e3a06778844c586251eb5a510f67125427625f9eb2b9526535779", size = 10990491, upload-time = "2026-02-12T23:09:25.503Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/00/50920cb385b89413f7cdb4bb9bc8fc59c1b0f30028d8bccc294189a54955/ruff-0.15.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66a6dd6df4d80dc382c6484f8ce1bcceb55c32e9f27a8b94c32f6c7331bf14fb", size = 11843280, upload-time = "2026-02-12T23:09:19.88Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/6d/2f5cad8380caf5632a15460c323ae326f1e1a2b5b90a6ee7519017a017ca/ruff-0.15.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6a4a42cbb8af0bda9bcd7606b064d7c0bc311a88d141d02f78920be6acb5aa83", size = 11274336, upload-time = "2026-02-12T23:09:14.907Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/1d/5f56cae1d6c40b8a318513599b35ea4b075d7dc1cd1d04449578c29d1d75/ruff-0.15.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4ab064052c31dddada35079901592dfba2e05f5b1e43af3954aafcbc1096a5b2", size = 11137288, upload-time = "2026-02-12T23:09:07.475Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/20/6f8d7d8f768c93b0382b33b9306b3b999918816da46537d5a61635514635/ruff-0.15.1-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:5631c940fe9fe91f817a4c2ea4e81f47bee3ca4aa646134a24374f3c19ad9454", size = 11070681, upload-time = "2026-02-12T23:08:55.43Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/67/d640ac76069f64cdea59dba02af2e00b1fa30e2103c7f8d049c0cff4cafd/ruff-0.15.1-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:68138a4ba184b4691ccdc39f7795c66b3c68160c586519e7e8444cf5a53e1b4c", size = 10486401, upload-time = "2026-02-12T23:09:27.927Z" },
+    { url = "https://files.pythonhosted.org/packages/65/3d/e1429f64a3ff89297497916b88c32a5cc88eeca7e9c787072d0e7f1d3e1e/ruff-0.15.1-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:518f9af03bfc33c03bdb4cb63fabc935341bb7f54af500f92ac309ecfbba6330", size = 10197452, upload-time = "2026-02-12T23:09:12.147Z" },
+    { url = "https://files.pythonhosted.org/packages/78/83/e2c3bade17dad63bf1e1c2ffaf11490603b760be149e1419b07049b36ef2/ruff-0.15.1-py3-none-musllinux_1_2_i686.whl", hash = "sha256:da79f4d6a826caaea95de0237a67e33b81e6ec2e25fc7e1993a4015dffca7c61", size = 10693900, upload-time = "2026-02-12T23:09:34.418Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/27/fdc0e11a813e6338e0706e8b39bb7a1d61ea5b36873b351acee7e524a72a/ruff-0.15.1-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:3dd86dccb83cd7d4dcfac303ffc277e6048600dfc22e38158afa208e8bf94a1f", size = 11227302, upload-time = "2026-02-12T23:09:36.536Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/58/ac864a75067dcbd3b95be5ab4eb2b601d7fbc3d3d736a27e391a4f92a5c1/ruff-0.15.1-py3-none-win32.whl", hash = "sha256:660975d9cb49b5d5278b12b03bb9951d554543a90b74ed5d366b20e2c57c2098", size = 10462555, upload-time = "2026-02-12T23:09:29.899Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/5e/d4ccc8a27ecdb78116feac4935dfc39d1304536f4296168f91ed3ec00cd2/ruff-0.15.1-py3-none-win_amd64.whl", hash = "sha256:c820fef9dd5d4172a6570e5721704a96c6679b80cf7be41659ed439653f62336", size = 11599956, upload-time = "2026-02-12T23:09:01.157Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/07/5bda6a85b220c64c65686bc85bd0bbb23b29c62b3a9f9433fa55f17cda93/ruff-0.15.1-py3-none-win_arm64.whl", hash = "sha256:5ff7d5f0f88567850f45081fac8f4ec212be8d0b963e385c3f7d0d2eb4899416", size = 10874604, upload-time = "2026-02-12T23:09:05.515Z" },
 ]
 
 [[package]]
@@ -3517,14 +3511,14 @@ wheels = [
 
 [[package]]
 name = "syrupy"
-version = "5.0.0"
+version = "5.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pytest" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c1/90/1a442d21527009d4b40f37fe50b606ebb68a6407142c2b5cc508c34b696b/syrupy-5.0.0.tar.gz", hash = "sha256:3282fe963fa5d4d3e47231b16d1d4d0f4523705e8199eeb99a22a1bc9f5942f2", size = 48881, upload-time = "2025-09-28T21:15:12.783Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/b0/24bca682d6a6337854be37f242d116cceeda9942571d5804c44bc1bdd427/syrupy-5.1.0.tar.gz", hash = "sha256:df543c7aa50d3cf1246e83d58fe490afe5f7dab7b41e74ecc0d8d23ae19bd4b8", size = 50495, upload-time = "2026-01-25T14:53:06.2Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9d/9a/6c68aad2ccfce6e2eeebbf5bb709d0240592eb51ff142ec4c8fbf3c2460a/syrupy-5.0.0-py3-none-any.whl", hash = "sha256:c848e1a980ca52a28715cd2d2b4d434db424699c05653bd1158fb31cf56e9546", size = 49087, upload-time = "2025-09-28T21:15:11.639Z" },
+    { url = "https://files.pythonhosted.org/packages/de/70/cf880c3b95a6034ef673e74b369941b42315c01f1554a5637a4f8b911009/syrupy-5.1.0-py3-none-any.whl", hash = "sha256:95162d2b05e61ed3e13f117b88dfab7c58bd6f90e66ebbf918e8a77114ad51c5", size = 51658, upload-time = "2026-01-25T14:53:05.105Z" },
 ]
 
 [[package]]
@@ -3757,34 +3751,46 @@ wheels = [
 
 [[package]]
 name = "uvloop"
-version = "0.21.0b1"
+version = "0.22.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/cf/3d/a150e044b5bc69961168b024c531d21b63acd9948b7d681b03e551be01e1/uvloop-0.21.0b1.tar.gz", hash = "sha256:5e12901bd67c5ba374741fc497adc44de14854895c416cd0672b2e5b676ca23c", size = 2492824, upload-time = "2024-09-03T00:05:35.885Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250, upload-time = "2025-10-16T22:17:19.342Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/43/66/9ec788eebd74f04a2756667d95c1d0f92f6a6bd9e5080e3d8b52ac32b682/uvloop-0.21.0b1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:b47c276e66f2a26b58eafd0745c788e7345c9445a9e4b7799dd7065445ca91bf", size = 1442073, upload-time = "2024-09-03T00:04:35.033Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/de/74daae1ae950c694ea8a9b1cc66a64835ebe795ed664d9b94e0a7e03a444/uvloop-0.21.0b1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5aec94e40549d8fd1b04dc50d1b4480d4e8e1ed61066798dade0b4ecd408e7ed", size = 801933, upload-time = "2024-09-03T00:04:36.983Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/0a/2a096412380fed5f7f253ee1b2019dde271a3b8905b3ab54706f3f10ef96/uvloop-0.21.0b1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8e867c5ffde9ec8880253a484a33a961e5af40e26757eda67a34798aabe471af", size = 3827869, upload-time = "2024-09-03T00:04:38.907Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/b4/bb6fc45e128e019c51a1561c72999f4d3777a42429b82a44acb672e6ce54/uvloop-0.21.0b1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1299f155b8dbe3374d1db810cb994cf22a3fadf8c5a85032aa8f31e18745a9c6", size = 3825264, upload-time = "2024-09-03T00:04:40.764Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/78/daae6af20422ec0436b297830355f934371cf20b149aaa6237dff8074864/uvloop-0.21.0b1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:2abfc1738c3fbb5a5552ea9fb34cca5cbdf73868caf78bdacdcd6ffbab438870", size = 3705923, upload-time = "2024-09-03T00:04:42.592Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/e6/cbfeaec2f2cacb1b30c9c71252a0660e0e4d5bbe57ba4789d5949157d2a2/uvloop-0.21.0b1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b3ac2b88f32612f7c4d792b3ed9b63eed414a1e85e004881a6ff08031c4ecf6c", size = 3800663, upload-time = "2024-09-03T00:04:44.523Z" },
-    { url = "https://files.pythonhosted.org/packages/41/58/113611cee5a47023d70bd4310e4a54a49b91e9f0214e801dc7f5dcd77eb1/uvloop-0.21.0b1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a156feb70518fd4d748209726463adf92d4dde895a137442956c66d6d3867fb8", size = 1447462, upload-time = "2024-09-03T00:04:46.128Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/0c/be081409798b7601788879646f4dab5794f54e19b38654257657ba1363dc/uvloop-0.21.0b1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:115c90a7ef29375104b153e474c7fdf1c2bbd409f0c13ecaa823ed92b2c145e7", size = 805502, upload-time = "2024-09-03T00:04:47.326Z" },
-    { url = "https://files.pythonhosted.org/packages/38/e8/158fbbef8ddd7cddb8a0b8e6351c0d208284bc101e5f9ab8c9c76fd70550/uvloop-0.21.0b1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79d0b7c1c1a98282ad3384bc4cf4f199431efa3f4e5eeda6785cb902703c9691", size = 3960996, upload-time = "2024-09-03T00:04:48.556Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/7e/840749f44fd277ee45f15773dc551e4119ac3ebb5601cfd7dce6c7ac0941/uvloop-0.21.0b1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:586c229730e74308763147195d908e7568c0769d05bafc132f4faaf655f6cffe", size = 3973317, upload-time = "2024-09-03T00:04:50.58Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/c7/49bba193c023ae4987fb05d90ae023f9e9da33535f74009159f8e77fc873/uvloop-0.21.0b1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bcddc39a94971bb5b8c76f243a8b467f7b69674bd25531b85b4d25d5917dd52f", size = 3820394, upload-time = "2024-09-03T00:04:52.227Z" },
-    { url = "https://files.pythonhosted.org/packages/34/30/e501868d7e46aeebe40fdf679c866a908c395a1ef2801777977b8c794585/uvloop-0.21.0b1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6c0332893fa201a60c4db7d6d296b131eb91793a062cfc9845bdcdab9cc6c22a", size = 3937456, upload-time = "2024-09-03T00:04:54.295Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/12/eb875804e318cf2b62958cc73830646354d30422d7766148898d7268b3d9/uvloop-0.21.0b1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:ea815a3046d31e3a88c09c13d46956f9b872a6951dd7ddee02ac8e3aa642a2de", size = 1471491, upload-time = "2024-09-03T00:04:56.203Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/4a/55aba98b01712e2074d0c4e8a8d4a9e17586ade0882609ba24af52c71393/uvloop-0.21.0b1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:cb788e15561dab81f5c562fb2496926a1b8b47d8ff1986d9b37acfa98b37faa9", size = 821594, upload-time = "2024-09-03T00:04:58.427Z" },
-    { url = "https://files.pythonhosted.org/packages/07/d4/fb855a16886212ad90acdad44442f08b278deeb870f9081626723df12f93/uvloop-0.21.0b1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0029380131aae418f4034520d853c85880d049eb1232214fda209a40a41c806c", size = 4580223, upload-time = "2024-09-03T00:05:00.134Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/19/8e0185567b072627ec9c103c7ec3abe002d03344d813ac8d79753de0adb9/uvloop-0.21.0b1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d692df286fe1df2659c2e26e1d4e582b02bf32847e675f7e6a770cc107ca4987", size = 4693904, upload-time = "2024-09-03T00:05:01.736Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/7b/79aba40e0850018fc575fd2289fd724e846231b66adbf7df080b7e62339e/uvloop-0.21.0b1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:19641b992c05a47169cc655b7fbe4628dd5f29cafc910ce87dbd1702609d3bb1", size = 4451455, upload-time = "2024-09-03T00:05:03.137Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/b7/9bf50763d2ea33b6db33d4d4d2ba792d326e217c2a9d7c749480f9c1b536/uvloop-0.21.0b1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:61b1c1d32df0a1ed0c8dca000ed15bab59e008349787d1d21b2a9d21ac7e5c8a", size = 4659154, upload-time = "2024-09-03T00:05:06.316Z" },
-    { url = "https://files.pythonhosted.org/packages/22/4b/b307b11ac3367cd8f5fd31614a2fa314d9ee639a71c435c79c9681a447d7/uvloop-0.21.0b1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:51f9ce02856cec8c7346875e40068b58fdf9c1f5326dbdf342c751abbcff40df", size = 1468145, upload-time = "2024-09-03T00:05:07.775Z" },
-    { url = "https://files.pythonhosted.org/packages/71/46/ef3cc31b1bce230879aa7fb164584b8101a882ff22503b666184c92ce130/uvloop-0.21.0b1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7fbd38cf672c6477ccd5d034a6c25db7fdb7ef3964f82d209cde41c9a2dfe09b", size = 819354, upload-time = "2024-09-03T00:05:09.066Z" },
-    { url = "https://files.pythonhosted.org/packages/94/80/20f933576d95bcc0eb4461b3ab7d7e3b63e69f69b4c83479a923ab9e612f/uvloop-0.21.0b1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1d2c4ae86218435cd76cb2f556433281923e15c22417d4ecb2f464325ed0dde3", size = 4583158, upload-time = "2024-09-03T00:05:10.398Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/a0/a70bab5bb54e6a5b2efab475e36aad6d1ffcbb2e31cb5132cba459f2e3e0/uvloop-0.21.0b1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ea6c55bbbdbf6cb7bc3693aa52d93c5efb4ded5be903b7faf0eb08e57f8dbfd5", size = 4701180, upload-time = "2024-09-03T00:05:11.91Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/78/3734fd63b1ae4c994af546fe4418b2c0af7b272cd0294bf5aa99bbf1b57f/uvloop-0.21.0b1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c5038ebc2f436398a153926db21d235ce75b050450af6bad17faee6336f6ef0b", size = 4454595, upload-time = "2024-09-03T00:05:13.764Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/ff/0d7cb5bce39f624a0aa8f2945cd52f4f946b1ca4aea8ef112c8c785649b1/uvloop-0.21.0b1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6af42e66212598a507879518f1fa8f13a489d52285e3715d1b4c91bcc70dd0ff", size = 4660273, upload-time = "2024-09-03T00:05:15.506Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/14/ecceb239b65adaaf7fde510aa8bd534075695d1e5f8dadfa32b5723d9cfb/uvloop-0.22.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:ef6f0d4cc8a9fa1f6a910230cd53545d9a14479311e87e3cb225495952eb672c", size = 1343335, upload-time = "2025-10-16T22:16:11.43Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/ae/6f6f9af7f590b319c94532b9567409ba11f4fa71af1148cab1bf48a07048/uvloop-0.22.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7cd375a12b71d33d46af85a3343b35d98e8116134ba404bd657b3b1d15988792", size = 742903, upload-time = "2025-10-16T22:16:12.979Z" },
+    { url = "https://files.pythonhosted.org/packages/09/bd/3667151ad0702282a1f4d5d29288fce8a13c8b6858bf0978c219cd52b231/uvloop-0.22.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ac33ed96229b7790eb729702751c0e93ac5bc3bcf52ae9eccbff30da09194b86", size = 3648499, upload-time = "2025-10-16T22:16:14.451Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/f6/21657bb3beb5f8c57ce8be3b83f653dd7933c2fd00545ed1b092d464799a/uvloop-0.22.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:481c990a7abe2c6f4fc3d98781cc9426ebd7f03a9aaa7eb03d3bfc68ac2a46bd", size = 3700133, upload-time = "2025-10-16T22:16:16.272Z" },
+    { url = "https://files.pythonhosted.org/packages/09/e0/604f61d004ded805f24974c87ddd8374ef675644f476f01f1df90e4cdf72/uvloop-0.22.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a592b043a47ad17911add5fbd087c76716d7c9ccc1d64ec9249ceafd735f03c2", size = 3512681, upload-time = "2025-10-16T22:16:18.07Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/ce/8491fd370b0230deb5eac69c7aae35b3be527e25a911c0acdffb922dc1cd/uvloop-0.22.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:1489cf791aa7b6e8c8be1c5a080bae3a672791fcb4e9e12249b05862a2ca9cec", size = 3615261, upload-time = "2025-10-16T22:16:19.596Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/d5/69900f7883235562f1f50d8184bb7dd84a2fb61e9ec63f3782546fdbd057/uvloop-0.22.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c60ebcd36f7b240b30788554b6f0782454826a0ed765d8430652621b5de674b9", size = 1352420, upload-time = "2025-10-16T22:16:21.187Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/73/c4e271b3bce59724e291465cc936c37758886a4868787da0278b3b56b905/uvloop-0.22.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3b7f102bf3cb1995cfeaee9321105e8f5da76fdb104cdad8986f85461a1b7b77", size = 748677, upload-time = "2025-10-16T22:16:22.558Z" },
+    { url = "https://files.pythonhosted.org/packages/86/94/9fb7fad2f824d25f8ecac0d70b94d0d48107ad5ece03769a9c543444f78a/uvloop-0.22.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53c85520781d84a4b8b230e24a5af5b0778efdb39142b424990ff1ef7c48ba21", size = 3753819, upload-time = "2025-10-16T22:16:23.903Z" },
+    { url = "https://files.pythonhosted.org/packages/74/4f/256aca690709e9b008b7108bc85fba619a2bc37c6d80743d18abad16ee09/uvloop-0.22.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:56a2d1fae65fd82197cb8c53c367310b3eabe1bbb9fb5a04d28e3e3520e4f702", size = 3804529, upload-time = "2025-10-16T22:16:25.246Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/74/03c05ae4737e871923d21a76fe28b6aad57f5c03b6e6bfcfa5ad616013e4/uvloop-0.22.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:40631b049d5972c6755b06d0bfe8233b1bd9a8a6392d9d1c45c10b6f9e9b2733", size = 3621267, upload-time = "2025-10-16T22:16:26.819Z" },
+    { url = "https://files.pythonhosted.org/packages/75/be/f8e590fe61d18b4a92070905497aec4c0e64ae1761498cad09023f3f4b3e/uvloop-0.22.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:535cc37b3a04f6cd2c1ef65fa1d370c9a35b6695df735fcff5427323f2cd5473", size = 3723105, upload-time = "2025-10-16T22:16:28.252Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/ff/7f72e8170be527b4977b033239a83a68d5c881cc4775fca255c677f7ac5d/uvloop-0.22.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fe94b4564e865d968414598eea1a6de60adba0c040ba4ed05ac1300de402cd42", size = 1359936, upload-time = "2025-10-16T22:16:29.436Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/c6/e5d433f88fd54d81ef4be58b2b7b0cea13c442454a1db703a1eea0db1a59/uvloop-0.22.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:51eb9bd88391483410daad430813d982010f9c9c89512321f5b60e2cddbdddd6", size = 752769, upload-time = "2025-10-16T22:16:30.493Z" },
+    { url = "https://files.pythonhosted.org/packages/24/68/a6ac446820273e71aa762fa21cdcc09861edd3536ff47c5cd3b7afb10eeb/uvloop-0.22.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:700e674a166ca5778255e0e1dc4e9d79ab2acc57b9171b79e65feba7184b3370", size = 4317413, upload-time = "2025-10-16T22:16:31.644Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4", size = 4426307, upload-time = "2025-10-16T22:16:32.917Z" },
+    { url = "https://files.pythonhosted.org/packages/90/60/97362554ac21e20e81bcef1150cb2a7e4ffdaf8ea1e5b2e8bf7a053caa18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e047cc068570bac9866237739607d1313b9253c3051ad84738cbb095be0537b2", size = 4131970, upload-time = "2025-10-16T22:16:34.015Z" },
+    { url = "https://files.pythonhosted.org/packages/99/39/6b3f7d234ba3964c428a6e40006340f53ba37993f46ed6e111c6e9141d18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:512fec6815e2dd45161054592441ef76c830eddaad55c8aa30952e6fe1ed07c0", size = 4296343, upload-time = "2025-10-16T22:16:35.149Z" },
+    { url = "https://files.pythonhosted.org/packages/89/8c/182a2a593195bfd39842ea68ebc084e20c850806117213f5a299dfc513d9/uvloop-0.22.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:561577354eb94200d75aca23fbde86ee11be36b00e52a4eaf8f50fb0c86b7705", size = 1358611, upload-time = "2025-10-16T22:16:36.833Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/14/e301ee96a6dc95224b6f1162cd3312f6d1217be3907b79173b06785f2fe7/uvloop-0.22.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cdf5192ab3e674ca26da2eada35b288d2fa49fdd0f357a19f0e7c4e7d5077c8", size = 751811, upload-time = "2025-10-16T22:16:38.275Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/02/654426ce265ac19e2980bfd9ea6590ca96a56f10c76e63801a2df01c0486/uvloop-0.22.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2ea3d6190a2968f4a14a23019d3b16870dd2190cd69c8180f7c632d21de68d", size = 4288562, upload-time = "2025-10-16T22:16:39.375Z" },
+    { url = "https://files.pythonhosted.org/packages/15/c0/0be24758891ef825f2065cd5db8741aaddabe3e248ee6acc5e8a80f04005/uvloop-0.22.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0530a5fbad9c9e4ee3f2b33b148c6a64d47bbad8000ea63704fa8260f4cf728e", size = 4366890, upload-time = "2025-10-16T22:16:40.547Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/53/8369e5219a5855869bcee5f4d317f6da0e2c669aecf0ef7d371e3d084449/uvloop-0.22.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bc5ef13bbc10b5335792360623cc378d52d7e62c2de64660616478c32cd0598e", size = 4119472, upload-time = "2025-10-16T22:16:41.694Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ba/d69adbe699b768f6b29a5eec7b47dd610bd17a69de51b251126a801369ea/uvloop-0.22.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1f38ec5e3f18c8a10ded09742f7fb8de0108796eb673f30ce7762ce1b8550cad", size = 4239051, upload-time = "2025-10-16T22:16:43.224Z" },
+    { url = "https://files.pythonhosted.org/packages/90/cd/b62bdeaa429758aee8de8b00ac0dd26593a9de93d302bff3d21439e9791d/uvloop-0.22.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3879b88423ec7e97cd4eba2a443aa26ed4e59b45e6b76aabf13fe2f27023a142", size = 1362067, upload-time = "2025-10-16T22:16:44.503Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/f8/a132124dfda0777e489ca86732e85e69afcd1ff7686647000050ba670689/uvloop-0.22.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4baa86acedf1d62115c1dc6ad1e17134476688f08c6efd8a2ab076e815665c74", size = 752423, upload-time = "2025-10-16T22:16:45.968Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/94/94af78c156f88da4b3a733773ad5ba0b164393e357cc4bd0ab2e2677a7d6/uvloop-0.22.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:297c27d8003520596236bdb2335e6b3f649480bd09e00d1e3a99144b691d2a35", size = 4272437, upload-time = "2025-10-16T22:16:47.451Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/35/60249e9fd07b32c665192cec7af29e06c7cd96fa1d08b84f012a56a0b38e/uvloop-0.22.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1955d5a1dd43198244d47664a5858082a3239766a839b2102a269aaff7a4e25", size = 4292101, upload-time = "2025-10-16T22:16:49.318Z" },
+    { url = "https://files.pythonhosted.org/packages/02/62/67d382dfcb25d0a98ce73c11ed1a6fba5037a1a1d533dcbb7cab033a2636/uvloop-0.22.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b31dc2fccbd42adc73bc4e7cdbae4fc5086cf378979e53ca5d0301838c5682c6", size = 4114158, upload-time = "2025-10-16T22:16:50.517Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/f1171b4a882a5d13c8b7576f348acfe6074d72eaf52cccef752f748d4a9f/uvloop-0.22.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:93f617675b2d03af4e72a5333ef89450dfaa5321303ede6e67ba9c9d26878079", size = 4177360, upload-time = "2025-10-16T22:16:52.646Z" },
+    { url = "https://files.pythonhosted.org/packages/79/7b/b01414f31546caf0919da80ad57cbfe24c56b151d12af68cee1b04922ca8/uvloop-0.22.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:37554f70528f60cad66945b885eb01f1bb514f132d92b6eeed1c90fd54ed6289", size = 1454790, upload-time = "2025-10-16T22:16:54.355Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/31/0bb232318dd838cad3fa8fb0c68c8b40e1145b32025581975e18b11fab40/uvloop-0.22.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b76324e2dc033a0b2f435f33eb88ff9913c156ef78e153fb210e03c13da746b3", size = 796783, upload-time = "2025-10-16T22:16:55.906Z" },
+    { url = "https://files.pythonhosted.org/packages/42/38/c9b09f3271a7a723a5de69f8e237ab8e7803183131bc57c890db0b6bb872/uvloop-0.22.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:badb4d8e58ee08dad957002027830d5c3b06aea446a6a3744483c2b3b745345c", size = 4647548, upload-time = "2025-10-16T22:16:57.008Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/37/945b4ca0ac27e3dc4952642d4c900edd030b3da6c9634875af6e13ae80e5/uvloop-0.22.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b91328c72635f6f9e0282e4a57da7470c7350ab1c9f48546c0f2866205349d21", size = 4467065, upload-time = "2025-10-16T22:16:58.206Z" },
+    { url = "https://files.pythonhosted.org/packages/97/cc/48d232f33d60e2e2e0b42f4e73455b146b76ebe216487e862700457fbf3c/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:daf620c2995d193449393d6c62131b3fbd40a63bf7b307a1527856ace637fe88", size = 4328384, upload-time = "2025-10-16T22:16:59.36Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/16/c1fd27e9549f3c4baf1dc9c20c456cd2f822dbf8de9f463824b0c0357e06/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6cde23eeda1a25c75b2e07d39970f3374105d5eafbaab2a4482be82f272d5a5e", size = 4296730, upload-time = "2025-10-16T22:17:00.744Z" },
 ]
 
 [[package]]

libs/prebuilt/uv.lock

@@ -249,7 +249,7 @@ wheels = [
 
 [[package]]
 name = "langchain-core"
-version = "1.2.7"
+version = "1.2.12"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jsonpatch" },
@@ -261,9 +261,9 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "uuid-utils" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a2/0e/664d8d81b3493e09cbab72448d2f9d693d1fa5aa2bcc488602203a9b6da0/langchain_core-1.2.7.tar.gz", hash = "sha256:e1460639f96c352b4a41c375f25aeb8d16ffc1769499fb1c20503aad59305ced", size = 837039, upload-time = "2026-01-09T17:44:25.505Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2a/1d/08e935d1532fcc90981f6e5bb6825914c9227ea7a962c62b1e18619b49e7/langchain_core-1.2.12.tar.gz", hash = "sha256:4d7fa6643d7ab06fc1905a9b7dcbe96a6f3c181046b56edf9c0c17ecd412d9e9", size = 831329, upload-time = "2026-02-12T20:53:15.01Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6e/6f/34a9fba14d191a67f7e2ee3dbce3e9b86d2fa7310e2c7f2c713583481bd2/langchain_core-1.2.7-py3-none-any.whl", hash = "sha256:452f4fef7a3d883357b22600788d37e3d8854ef29da345b7ac7099f33c31828b", size = 490232, upload-time = "2026-01-09T17:44:24.236Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/a5/678ab0e5cc57794f20ae5ed12c1442506ef1108c9434f950aebc6044e5a3/langchain_core-1.2.12-py3-none-any.whl", hash = "sha256:66ca17a2a9cb007ab29021968e6adfcf4228067151dc2bd6ebfff265ffaf92f5", size = 500132, upload-time = "2026-02-12T20:53:13.806Z" },
 ]
 
 [[package]]
@@ -317,7 +317,7 @@ dev = [
     { name = "ruff" },
     { name = "syrupy" },
     { name = "types-requests" },
-    { name = "uvloop", specifier = "==0.21.0b1" },
+    { name = "uvloop", specifier = "==0.22.1" },
 ]
 lint = [
     { name = "mypy" },
@@ -347,7 +347,7 @@ test = [
     { name = "pytest-xdist", extras = ["psutil"] },
     { name = "redis" },
     { name = "syrupy" },
-    { name = "uvloop", specifier = "==0.21.0b1" },
+    { name = "uvloop", specifier = "==0.22.1" },
 ]
 
 [[package]]
@@ -592,22 +592,22 @@ requires-dist = [
 dev = [
     { name = "codespell" },
     { name = "langgraph", editable = "../langgraph" },
-    { name = "mypy", specifier = "==1.19.0" },
+    { name = "mypy", specifier = "==1.19.1" },
     { name = "pydantic", specifier = ">=2.12.4" },
     { name = "pytest" },
     { name = "pytest-asyncio" },
     { name = "pytest-mock" },
     { name = "pytest-watch" },
-    { name = "ruff", specifier = "==0.14.11" },
+    { name = "ruff", specifier = "==0.15.1" },
     { name = "starlette" },
-    { name = "ty", specifier = "==0.0.1a27" },
+    { name = "ty", specifier = "==0.0.17" },
 ]
 lint = [
     { name = "codespell" },
-    { name = "mypy", specifier = "==1.19.0" },
-    { name = "ruff", specifier = "==0.14.11" },
+    { name = "mypy", specifier = "==1.19.1" },
+    { name = "ruff", specifier = "==0.15.1" },
     { name = "starlette" },
-    { name = "ty", specifier = "==0.0.1a27" },
+    { name = "ty", specifier = "==0.0.17" },
 ]
 test = [
     { name = "pytest" },
@@ -1305,28 +1305,27 @@ wheels = [
 
 [[package]]
 name = "ruff"
-version = "0.14.13"
+version = "0.15.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/50/0a/1914efb7903174b381ee2ffeebb4253e729de57f114e63595114c8ca451f/ruff-0.14.13.tar.gz", hash = "sha256:83cd6c0763190784b99650a20fec7633c59f6ebe41c5cc9d45ee42749563ad47", size = 6059504, upload-time = "2026-01-15T20:15:16.918Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/dc/4e6ac71b511b141cf626357a3946679abeba4cf67bc7cc5a17920f31e10d/ruff-0.15.1.tar.gz", hash = "sha256:c590fe13fb57c97141ae975c03a1aedb3d3156030cabd740d6ff0b0d601e203f", size = 4540855, upload-time = "2026-02-12T23:09:09.998Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c3/ae/0deefbc65ca74b0ab1fd3917f94dc3b398233346a74b8bbb0a916a1a6bf6/ruff-0.14.13-py3-none-linux_armv6l.whl", hash = "sha256:76f62c62cd37c276cb03a275b198c7c15bd1d60c989f944db08a8c1c2dbec18b", size = 13062418, upload-time = "2026-01-15T20:14:50.779Z" },
-    { url = "https://files.pythonhosted.org/packages/47/df/5916604faa530a97a3c154c62a81cb6b735c0cb05d1e26d5ad0f0c8ac48a/ruff-0.14.13-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:914a8023ece0528d5cc33f5a684f5f38199bbb566a04815c2c211d8f40b5d0ed", size = 13442344, upload-time = "2026-01-15T20:15:07.94Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/f3/e0e694dd69163c3a1671e102aa574a50357536f18a33375050334d5cd517/ruff-0.14.13-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d24899478c35ebfa730597a4a775d430ad0d5631b8647a3ab368c29b7e7bd063", size = 12354720, upload-time = "2026-01-15T20:15:09.854Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/e8/67f5fcbbaee25e8fc3b56cc33e9892eca7ffe09f773c8e5907757a7e3bdb/ruff-0.14.13-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9aaf3870f14d925bbaf18b8a2347ee0ae7d95a2e490e4d4aea6813ed15ebc80e", size = 12774493, upload-time = "2026-01-15T20:15:20.908Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/ce/d2e9cb510870b52a9565d885c0d7668cc050e30fa2c8ac3fb1fda15c083d/ruff-0.14.13-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac5b7f63dd3b27cc811850f5ffd8fff845b00ad70e60b043aabf8d6ecc304e09", size = 12815174, upload-time = "2026-01-15T20:15:05.74Z" },
-    { url = "https://files.pythonhosted.org/packages/88/00/c38e5da58beebcf4fa32d0ddd993b63dfacefd02ab7922614231330845bf/ruff-0.14.13-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:78d2b1097750d90ba82ce4ba676e85230a0ed694178ca5e61aa9b459970b3eb9", size = 13680909, upload-time = "2026-01-15T20:15:14.537Z" },
-    { url = "https://files.pythonhosted.org/packages/61/61/cd37c9dd5bd0a3099ba79b2a5899ad417d8f3b04038810b0501a80814fd7/ruff-0.14.13-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:7d0bf87705acbbcb8d4c24b2d77fbb73d40210a95c3903b443cd9e30824a5032", size = 15144215, upload-time = "2026-01-15T20:15:22.886Z" },
-    { url = "https://files.pythonhosted.org/packages/56/8a/85502d7edbf98c2df7b8876f316c0157359165e16cdf98507c65c8d07d3d/ruff-0.14.13-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a3eb5da8e2c9e9f13431032fdcbe7681de9ceda5835efee3269417c13f1fed5c", size = 14706067, upload-time = "2026-01-15T20:14:48.271Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/2f/de0df127feb2ee8c1e54354dc1179b4a23798f0866019528c938ba439aca/ruff-0.14.13-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:642442b42957093811cd8d2140dfadd19c7417030a7a68cf8d51fcdd5f217427", size = 14133916, upload-time = "2026-01-15T20:14:57.357Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/77/9b99686bb9fe07a757c82f6f95e555c7a47801a9305576a9c67e0a31d280/ruff-0.14.13-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4acdf009f32b46f6e8864af19cbf6841eaaed8638e65c8dac845aea0d703c841", size = 13859207, upload-time = "2026-01-15T20:14:55.111Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/46/2bdcb34a87a179a4d23022d818c1c236cb40e477faf0d7c9afb6813e5876/ruff-0.14.13-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:591a7f68860ea4e003917d19b5c4f5ac39ff558f162dc753a2c5de897fd5502c", size = 14043686, upload-time = "2026-01-15T20:14:52.841Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/a9/5c6a4f56a0512c691cf143371bcf60505ed0f0860f24a85da8bd123b2bf1/ruff-0.14.13-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:774c77e841cc6e046fc3e91623ce0903d1cd07e3a36b1a9fe79b81dab3de506b", size = 12663837, upload-time = "2026-01-15T20:15:18.921Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/bb/b920016ece7651fa7fcd335d9d199306665486694d4361547ccb19394c44/ruff-0.14.13-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:61f4e40077a1248436772bb6512db5fc4457fe4c49e7a94ea7c5088655dd21ae", size = 12805867, upload-time = "2026-01-15T20:14:59.272Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/b3/0bd909851e5696cd21e32a8fc25727e5f58f1934b3596975503e6e85415c/ruff-0.14.13-py3-none-musllinux_1_2_i686.whl", hash = "sha256:6d02f1428357fae9e98ac7aa94b7e966fd24151088510d32cf6f902d6c09235e", size = 13208528, upload-time = "2026-01-15T20:15:03.732Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/3b/e2d94cb613f6bbd5155a75cbe072813756363eba46a3f2177a1fcd0cd670/ruff-0.14.13-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e399341472ce15237be0c0ae5fbceca4b04cd9bebab1a2b2c979e015455d8f0c", size = 13929242, upload-time = "2026-01-15T20:15:11.918Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/c5/abd840d4132fd51a12f594934af5eba1d5d27298a6f5b5d6c3be45301caf/ruff-0.14.13-py3-none-win32.whl", hash = "sha256:ef720f529aec113968b45dfdb838ac8934e519711da53a0456038a0efecbd680", size = 12919024, upload-time = "2026-01-15T20:14:43.647Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/55/6384b0b8ce731b6e2ade2b5449bf07c0e4c31e8a2e68ea65b3bafadcecc5/ruff-0.14.13-py3-none-win_amd64.whl", hash = "sha256:6070bd026e409734b9257e03e3ef18c6e1a216f0435c6751d7a8ec69cb59abef", size = 14097887, upload-time = "2026-01-15T20:15:01.48Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/e1/7348090988095e4e39560cfc2f7555b1b2a7357deba19167b600fdf5215d/ruff-0.14.13-py3-none-win_arm64.whl", hash = "sha256:7ab819e14f1ad9fe39f246cfcc435880ef7a9390d81a2b6ac7e01039083dd247", size = 13080224, upload-time = "2026-01-15T20:14:45.853Z" },
+    { url = "https://files.pythonhosted.org/packages/23/bf/e6e4324238c17f9d9120a9d60aa99a7daaa21204c07fcd84e2ef03bb5fd1/ruff-0.15.1-py3-none-linux_armv6l.whl", hash = "sha256:b101ed7cf4615bda6ffe65bdb59f964e9f4a0d3f85cbf0e54f0ab76d7b90228a", size = 10367819, upload-time = "2026-02-12T23:09:03.598Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/ea/c8f89d32e7912269d38c58f3649e453ac32c528f93bb7f4219258be2e7ed/ruff-0.15.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:939c995e9277e63ea632cc8d3fae17aa758526f49a9a850d2e7e758bfef46602", size = 10798618, upload-time = "2026-02-12T23:09:22.928Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/0f/1d0d88bc862624247d82c20c10d4c0f6bb2f346559d8af281674cf327f15/ruff-0.15.1-py3-none-macosx_11_0_arm64.whl", hash = "sha256:1d83466455fdefe60b8d9c8df81d3c1bbb2115cede53549d3b522ce2bc703899", size = 10148518, upload-time = "2026-02-12T23:08:58.339Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/c8/291c49cefaa4a9248e986256df2ade7add79388fe179e0691be06fae6f37/ruff-0.15.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9457e3c3291024866222b96108ab2d8265b477e5b1534c7ddb1810904858d16", size = 10518811, upload-time = "2026-02-12T23:09:31.865Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/1a/f5707440e5ae43ffa5365cac8bbb91e9665f4a883f560893829cf16a606b/ruff-0.15.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:92c92b003e9d4f7fbd33b1867bb15a1b785b1735069108dfc23821ba045b29bc", size = 10196169, upload-time = "2026-02-12T23:09:17.306Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/ff/26ddc8c4da04c8fd3ee65a89c9fb99eaa5c30394269d424461467be2271f/ruff-0.15.1-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fe5c41ab43e3a06778844c586251eb5a510f67125427625f9eb2b9526535779", size = 10990491, upload-time = "2026-02-12T23:09:25.503Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/00/50920cb385b89413f7cdb4bb9bc8fc59c1b0f30028d8bccc294189a54955/ruff-0.15.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66a6dd6df4d80dc382c6484f8ce1bcceb55c32e9f27a8b94c32f6c7331bf14fb", size = 11843280, upload-time = "2026-02-12T23:09:19.88Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/6d/2f5cad8380caf5632a15460c323ae326f1e1a2b5b90a6ee7519017a017ca/ruff-0.15.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6a4a42cbb8af0bda9bcd7606b064d7c0bc311a88d141d02f78920be6acb5aa83", size = 11274336, upload-time = "2026-02-12T23:09:14.907Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/1d/5f56cae1d6c40b8a318513599b35ea4b075d7dc1cd1d04449578c29d1d75/ruff-0.15.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4ab064052c31dddada35079901592dfba2e05f5b1e43af3954aafcbc1096a5b2", size = 11137288, upload-time = "2026-02-12T23:09:07.475Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/20/6f8d7d8f768c93b0382b33b9306b3b999918816da46537d5a61635514635/ruff-0.15.1-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:5631c940fe9fe91f817a4c2ea4e81f47bee3ca4aa646134a24374f3c19ad9454", size = 11070681, upload-time = "2026-02-12T23:08:55.43Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/67/d640ac76069f64cdea59dba02af2e00b1fa30e2103c7f8d049c0cff4cafd/ruff-0.15.1-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:68138a4ba184b4691ccdc39f7795c66b3c68160c586519e7e8444cf5a53e1b4c", size = 10486401, upload-time = "2026-02-12T23:09:27.927Z" },
+    { url = "https://files.pythonhosted.org/packages/65/3d/e1429f64a3ff89297497916b88c32a5cc88eeca7e9c787072d0e7f1d3e1e/ruff-0.15.1-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:518f9af03bfc33c03bdb4cb63fabc935341bb7f54af500f92ac309ecfbba6330", size = 10197452, upload-time = "2026-02-12T23:09:12.147Z" },
+    { url = "https://files.pythonhosted.org/packages/78/83/e2c3bade17dad63bf1e1c2ffaf11490603b760be149e1419b07049b36ef2/ruff-0.15.1-py3-none-musllinux_1_2_i686.whl", hash = "sha256:da79f4d6a826caaea95de0237a67e33b81e6ec2e25fc7e1993a4015dffca7c61", size = 10693900, upload-time = "2026-02-12T23:09:34.418Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/27/fdc0e11a813e6338e0706e8b39bb7a1d61ea5b36873b351acee7e524a72a/ruff-0.15.1-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:3dd86dccb83cd7d4dcfac303ffc277e6048600dfc22e38158afa208e8bf94a1f", size = 11227302, upload-time = "2026-02-12T23:09:36.536Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/58/ac864a75067dcbd3b95be5ab4eb2b601d7fbc3d3d736a27e391a4f92a5c1/ruff-0.15.1-py3-none-win32.whl", hash = "sha256:660975d9cb49b5d5278b12b03bb9951d554543a90b74ed5d366b20e2c57c2098", size = 10462555, upload-time = "2026-02-12T23:09:29.899Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/5e/d4ccc8a27ecdb78116feac4935dfc39d1304536f4296168f91ed3ec00cd2/ruff-0.15.1-py3-none-win_amd64.whl", hash = "sha256:c820fef9dd5d4172a6570e5721704a96c6679b80cf7be41659ed439653f62336", size = 11599956, upload-time = "2026-02-12T23:09:01.157Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/07/5bda6a85b220c64c65686bc85bd0bbb23b29c62b3a9f9433fa55f17cda93/ruff-0.15.1-py3-none-win_arm64.whl", hash = "sha256:5ff7d5f0f88567850f45081fac8f4ec212be8d0b963e385c3f7d0d2eb4899416", size = 10874604, upload-time = "2026-02-12T23:09:05.515Z" },
 ]
 
 [[package]]
@@ -1343,14 +1342,14 @@ wheels = [
 
 [[package]]
 name = "syrupy"
-version = "5.0.0"
+version = "5.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pytest" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c1/90/1a442d21527009d4b40f37fe50b606ebb68a6407142c2b5cc508c34b696b/syrupy-5.0.0.tar.gz", hash = "sha256:3282fe963fa5d4d3e47231b16d1d4d0f4523705e8199eeb99a22a1bc9f5942f2", size = 48881, upload-time = "2025-09-28T21:15:12.783Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/b0/24bca682d6a6337854be37f242d116cceeda9942571d5804c44bc1bdd427/syrupy-5.1.0.tar.gz", hash = "sha256:df543c7aa50d3cf1246e83d58fe490afe5f7dab7b41e74ecc0d8d23ae19bd4b8", size = 50495, upload-time = "2026-01-25T14:53:06.2Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9d/9a/6c68aad2ccfce6e2eeebbf5bb709d0240592eb51ff142ec4c8fbf3c2460a/syrupy-5.0.0-py3-none-any.whl", hash = "sha256:c848e1a980ca52a28715cd2d2b4d434db424699c05653bd1158fb31cf56e9546", size = 49087, upload-time = "2025-09-28T21:15:11.639Z" },
+    { url = "https://files.pythonhosted.org/packages/de/70/cf880c3b95a6034ef673e74b369941b42315c01f1554a5637a4f8b911009/syrupy-5.1.0-py3-none-any.whl", hash = "sha256:95162d2b05e61ed3e13f117b88dfab7c58bd6f90e66ebbf918e8a77114ad51c5", size = 51658, upload-time = "2026-01-25T14:53:05.105Z" },
 ]
 
 [[package]]

libs/sdk-py/langgraph_sdk/__init__.py

@@ -3,6 +3,6 @@ from langgraph_sdk.client import get_client, get_sync_client
 from langgraph_sdk.encryption import Encryption
 from langgraph_sdk.encryption.types import EncryptionContext
 
-__version__ = "0.3.5"
+__version__ = "0.3.6"
 
 __all__ = ["Auth", "Encryption", "EncryptionContext", "get_client", "get_sync_client"]

libs/sdk-py/langgraph_sdk/_async/__init__.py

@@ -0,0 +1,20 @@
+"""Async client exports."""
+
+from langgraph_sdk._async.assistants import AssistantsClient
+from langgraph_sdk._async.client import LangGraphClient, get_client
+from langgraph_sdk._async.cron import CronClient
+from langgraph_sdk._async.http import HttpClient
+from langgraph_sdk._async.runs import RunsClient
+from langgraph_sdk._async.store import StoreClient
+from langgraph_sdk._async.threads import ThreadsClient
+
+__all__ = [
+    "AssistantsClient",
+    "CronClient",
+    "HttpClient",
+    "LangGraphClient",
+    "RunsClient",
+    "StoreClient",
+    "ThreadsClient",
+    "get_client",
+]

libs/sdk-py/langgraph_sdk/_async/assistants.py

@@ -0,0 +1,733 @@
+"""Async client for managing assistants in LangGraph."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Literal, cast, overload
+
+import httpx
+
+from langgraph_sdk._async.http import HttpClient
+from langgraph_sdk.schema import (
+    Assistant,
+    AssistantSelectField,
+    AssistantSortBy,
+    AssistantsSearchResponse,
+    AssistantVersion,
+    Config,
+    Context,
+    GraphSchema,
+    Json,
+    OnConflictBehavior,
+    QueryParamTypes,
+    SortOrder,
+    Subgraphs,
+)
+
+
+class AssistantsClient:
+    """Client for managing assistants in LangGraph.
+
+    This class provides methods to interact with assistants,
+    which are versioned configurations of your graph.
+
+    ???+ example "Example"
+
+        ```python
+        client = get_client(url="http://localhost:2024")
+        assistant = await client.assistants.get("assistant_id_123")
+        ```
+    """
+
+    def __init__(self, http: HttpClient) -> None:
+        self.http = http
+
+    async def get(
+        self,
+        assistant_id: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Assistant:
+        """Get an assistant by ID.
+
+        Args:
+            assistant_id: The ID of the assistant to get.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            Assistant: Assistant Object.
+
+        ???+ example "Example Usage"
+
+            ```python
+            assistant = await client.assistants.get(
+                assistant_id="my_assistant_id"
+            )
+            print(assistant)
+            ```
+
+            ```shell
+            ----------------------------------------------------
+
+            {
+                'assistant_id': 'my_assistant_id',
+                'graph_id': 'agent',
+                'created_at': '2024-06-25T17:10:33.109781+00:00',
+                'updated_at': '2024-06-25T17:10:33.109781+00:00',
+                'config': {},
+                'metadata': {'created_by': 'system'},
+                'version': 1,
+                'name': 'my_assistant'
+            }
+            ```
+        """
+        return await self.http.get(
+            f"/assistants/{assistant_id}", headers=headers, params=params
+        )
+
+    async def get_graph(
+        self,
+        assistant_id: str,
+        *,
+        xray: int | bool = False,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> dict[str, list[dict[str, Any]]]:
+        """Get the graph of an assistant by ID.
+
+        Args:
+            assistant_id: The ID of the assistant to get the graph of.
+            xray: Include graph representation of subgraphs. If an integer value is provided, only subgraphs with a depth less than or equal to the value will be included.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            Graph: The graph information for the assistant in JSON format.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            graph_info = await client.assistants.get_graph(
+                assistant_id="my_assistant_id"
+            )
+            print(graph_info)
+            ```
+
+            ```shell
+
+            --------------------------------------------------------------------------------------------------------------------------
+
+            {
+                'nodes':
+                    [
+                        {'id': '__start__', 'type': 'schema', 'data': '__start__'},
+                        {'id': '__end__', 'type': 'schema', 'data': '__end__'},
+                        {'id': 'agent','type': 'runnable','data': {'id': ['langgraph', 'utils', 'RunnableCallable'],'name': 'agent'}},
+                    ],
+                'edges':
+                    [
+                        {'source': '__start__', 'target': 'agent'},
+                        {'source': 'agent','target': '__end__'}
+                    ]
+            }
+            ```
+
+
+        """
+        query_params = {"xray": xray}
+        if params:
+            query_params.update(params)
+
+        return await self.http.get(
+            f"/assistants/{assistant_id}/graph", params=query_params, headers=headers
+        )
+
+    async def get_schemas(
+        self,
+        assistant_id: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> GraphSchema:
+        """Get the schemas of an assistant by ID.
+
+        Args:
+            assistant_id: The ID of the assistant to get the schema of.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            GraphSchema: The graph schema for the assistant.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            schema = await client.assistants.get_schemas(
+                assistant_id="my_assistant_id"
+            )
+            print(schema)
+            ```
+
+            ```shell
+
+            ----------------------------------------------------------------------------------------------------------------------------
+
+            {
+                'graph_id': 'agent',
+                'state_schema':
+                    {
+                        'title': 'LangGraphInput',
+                        '$ref': '#/definitions/AgentState',
+                        'definitions':
+                            {
+                                'BaseMessage':
+                                    {
+                                        'title': 'BaseMessage',
+                                        'description': 'Base abstract Message class. Messages are the inputs and outputs of ChatModels.',
+                                        'type': 'object',
+                                        'properties':
+                                            {
+                                             'content':
+                                                {
+                                                    'title': 'Content',
+                                                    'anyOf': [
+                                                        {'type': 'string'},
+                                                        {'type': 'array','items': {'anyOf': [{'type': 'string'}, {'type': 'object'}]}}
+                                                    ]
+                                                },
+                                            'additional_kwargs':
+                                                {
+                                                    'title': 'Additional Kwargs',
+                                                    'type': 'object'
+                                                },
+                                            'response_metadata':
+                                                {
+                                                    'title': 'Response Metadata',
+                                                    'type': 'object'
+                                                },
+                                            'type':
+                                                {
+                                                    'title': 'Type',
+                                                    'type': 'string'
+                                                },
+                                            'name':
+                                                {
+                                                    'title': 'Name',
+                                                    'type': 'string'
+                                                },
+                                            'id':
+                                                {
+                                                    'title': 'Id',
+                                                    'type': 'string'
+                                                }
+                                            },
+                                        'required': ['content', 'type']
+                                    },
+                                'AgentState':
+                                    {
+                                        'title': 'AgentState',
+                                        'type': 'object',
+                                        'properties':
+                                            {
+                                                'messages':
+                                                    {
+                                                        'title': 'Messages',
+                                                        'type': 'array',
+                                                        'items': {'$ref': '#/definitions/BaseMessage'}
+                                                    }
+                                            },
+                                        'required': ['messages']
+                                    }
+                            }
+                    },
+                'context_schema':
+                    {
+                        'title': 'Context',
+                        'type': 'object',
+                        'properties':
+                            {
+                                'model_name':
+                                    {
+                                        'title': 'Model Name',
+                                        'enum': ['anthropic', 'openai'],
+                                        'type': 'string'
+                                    }
+                            }
+                    }
+            }
+            ```
+
+        """
+        return await self.http.get(
+            f"/assistants/{assistant_id}/schemas", headers=headers, params=params
+        )
+
+    async def get_subgraphs(
+        self,
+        assistant_id: str,
+        namespace: str | None = None,
+        recurse: bool = False,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Subgraphs:
+        """Get the schemas of an assistant by ID.
+
+        Args:
+            assistant_id: The ID of the assistant to get the schema of.
+            namespace: Optional namespace to filter by.
+            recurse: Whether to recursively get subgraphs.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            Subgraphs: The graph schema for the assistant.
+
+        """
+        get_params = {"recurse": recurse}
+        if params:
+            get_params = {**get_params, **params}
+        if namespace is not None:
+            return await self.http.get(
+                f"/assistants/{assistant_id}/subgraphs/{namespace}",
+                params=get_params,
+                headers=headers,
+            )
+        else:
+            return await self.http.get(
+                f"/assistants/{assistant_id}/subgraphs",
+                params=get_params,
+                headers=headers,
+            )
+
+    async def create(
+        self,
+        graph_id: str | None,
+        config: Config | None = None,
+        *,
+        context: Context | None = None,
+        metadata: Json = None,
+        assistant_id: str | None = None,
+        if_exists: OnConflictBehavior | None = None,
+        name: str | None = None,
+        headers: Mapping[str, str] | None = None,
+        description: str | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Assistant:
+        """Create a new assistant.
+
+        Useful when graph is configurable and you want to create different assistants based on different configurations.
+
+        Args:
+            graph_id: The ID of the graph the assistant should use. The graph ID is normally set in your langgraph.json configuration.
+            config: Configuration to use for the graph.
+            metadata: Metadata to add to assistant.
+            context: Static context to add to the assistant.
+                !!! version-added "Added in version 0.6.0"
+            assistant_id: Assistant ID to use, will default to a random UUID if not provided.
+            if_exists: How to handle duplicate creation. Defaults to 'raise' under the hood.
+                Must be either 'raise' (raise error if duplicate), or 'do_nothing' (return existing assistant).
+            name: The name of the assistant. Defaults to 'Untitled' under the hood.
+            headers: Optional custom headers to include with the request.
+            description: Optional description of the assistant.
+                The description field is available for langgraph-api server version>=0.0.45
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            Assistant: The created assistant.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            assistant = await client.assistants.create(
+                graph_id="agent",
+                context={"model_name": "openai"},
+                metadata={"number":1},
+                assistant_id="my-assistant-id",
+                if_exists="do_nothing",
+                name="my_name"
+            )
+            ```
+        """
+        payload: dict[str, Any] = {
+            "graph_id": graph_id,
+        }
+        if config:
+            payload["config"] = config
+        if context:
+            payload["context"] = context
+        if metadata:
+            payload["metadata"] = metadata
+        if assistant_id:
+            payload["assistant_id"] = assistant_id
+        if if_exists:
+            payload["if_exists"] = if_exists
+        if name:
+            payload["name"] = name
+        if description:
+            payload["description"] = description
+        return await self.http.post(
+            "/assistants", json=payload, headers=headers, params=params
+        )
+
+    async def update(
+        self,
+        assistant_id: str,
+        *,
+        graph_id: str | None = None,
+        config: Config | None = None,
+        context: Context | None = None,
+        metadata: Json = None,
+        name: str | None = None,
+        headers: Mapping[str, str] | None = None,
+        description: str | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Assistant:
+        """Update an assistant.
+
+        Use this to point to a different graph, update the configuration, or change the metadata of an assistant.
+
+        Args:
+            assistant_id: Assistant to update.
+            graph_id: The ID of the graph the assistant should use.
+                The graph ID is normally set in your langgraph.json configuration. If `None`, assistant will keep pointing to same graph.
+            config: Configuration to use for the graph.
+            context: Static context to add to the assistant.
+                !!! version-added "Added in version 0.6.0"
+            metadata: Metadata to merge with existing assistant metadata.
+            name: The new name for the assistant.
+            headers: Optional custom headers to include with the request.
+            description: Optional description of the assistant.
+                The description field is available for langgraph-api server version>=0.0.45
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            The updated assistant.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            assistant = await client.assistants.update(
+                assistant_id='e280dad7-8618-443f-87f1-8e41841c180f',
+                graph_id="other-graph",
+                context={"model_name": "anthropic"},
+                metadata={"number":2}
+            )
+            ```
+
+        """
+        payload: dict[str, Any] = {}
+        if graph_id:
+            payload["graph_id"] = graph_id
+        if config:
+            payload["config"] = config
+        if context:
+            payload["context"] = context
+        if metadata:
+            payload["metadata"] = metadata
+        if name:
+            payload["name"] = name
+        if description:
+            payload["description"] = description
+        return await self.http.patch(
+            f"/assistants/{assistant_id}",
+            json=payload,
+            headers=headers,
+            params=params,
+        )
+
+    async def delete(
+        self,
+        assistant_id: str,
+        *,
+        delete_threads: bool = False,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None:
+        """Delete an assistant.
+
+        Args:
+            assistant_id: The assistant ID to delete.
+            delete_threads: If true, delete all threads with `metadata.assistant_id`
+                matching this assistant, along with runs and checkpoints belonging to
+                those threads.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            await client.assistants.delete(
+                assistant_id="my_assistant_id"
+            )
+            ```
+
+        """
+        query_params: dict[str, Any] = {}
+        if delete_threads:
+            query_params["delete_threads"] = True
+        if params:
+            query_params.update(params)
+        await self.http.delete(
+            f"/assistants/{assistant_id}",
+            headers=headers,
+            params=query_params or None,
+        )
+
+    @overload
+    async def search(
+        self,
+        *,
+        metadata: Json = None,
+        graph_id: str | None = None,
+        name: str | None = None,
+        limit: int = 10,
+        offset: int = 0,
+        sort_by: AssistantSortBy | None = None,
+        sort_order: SortOrder | None = None,
+        select: list[AssistantSelectField] | None = None,
+        response_format: Literal["object"],
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> AssistantsSearchResponse: ...
+
+    @overload
+    async def search(
+        self,
+        *,
+        metadata: Json = None,
+        graph_id: str | None = None,
+        name: str | None = None,
+        limit: int = 10,
+        offset: int = 0,
+        sort_by: AssistantSortBy | None = None,
+        sort_order: SortOrder | None = None,
+        select: list[AssistantSelectField] | None = None,
+        response_format: Literal["array"] = "array",
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> list[Assistant]: ...
+
+    async def search(
+        self,
+        *,
+        metadata: Json = None,
+        graph_id: str | None = None,
+        name: str | None = None,
+        limit: int = 10,
+        offset: int = 0,
+        sort_by: AssistantSortBy | None = None,
+        sort_order: SortOrder | None = None,
+        select: list[AssistantSelectField] | None = None,
+        response_format: Literal["array", "object"] = "array",
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> AssistantsSearchResponse | list[Assistant]:
+        """Search for assistants.
+
+        Args:
+            metadata: Metadata to filter by. Exact match filter for each KV pair.
+            graph_id: The ID of the graph to filter by.
+                The graph ID is normally set in your langgraph.json configuration.
+            name: The name of the assistant to filter by.
+                The filtering logic will match assistants where 'name' is a substring (case insensitive) of the assistant name.
+            limit: The maximum number of results to return.
+            offset: The number of results to skip.
+            sort_by: The field to sort by.
+            sort_order: The order to sort by.
+            select: Specific assistant fields to include in the response.
+            response_format: Controls the response shape. Use `"array"` (default)
+                to return a bare list of assistants, or `"object"` to return
+                a mapping containing assistants plus pagination metadata.
+                Defaults to "array", though this default will be changed to "object" in a future release.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            A list of assistants (when `response_format="array"`) or a mapping
+            with the assistants and the next pagination cursor (when
+            `response_format="object"`).
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            response = await client.assistants.search(
+                metadata = {"name":"my_name"},
+                graph_id="my_graph_id",
+                limit=5,
+                offset=5,
+                response_format="object"
+            )
+            next_cursor = response["next"]
+            assistants = response["assistants"]
+            ```
+        """
+        if response_format not in ("array", "object"):
+            raise ValueError(
+                f"response_format must be 'array' or 'object', got {response_format!r}"
+            )
+        payload: dict[str, Any] = {
+            "limit": limit,
+            "offset": offset,
+        }
+        if metadata:
+            payload["metadata"] = metadata
+        if graph_id:
+            payload["graph_id"] = graph_id
+        if name:
+            payload["name"] = name
+        if sort_by:
+            payload["sort_by"] = sort_by
+        if sort_order:
+            payload["sort_order"] = sort_order
+        if select:
+            payload["select"] = select
+        next_cursor: str | None = None
+
+        def capture_pagination(response: httpx.Response) -> None:
+            nonlocal next_cursor
+            next_cursor = response.headers.get("X-Pagination-Next")
+
+        assistants = cast(
+            list[Assistant],
+            await self.http.post(
+                "/assistants/search",
+                json=payload,
+                headers=headers,
+                params=params,
+                on_response=capture_pagination if response_format == "object" else None,
+            ),
+        )
+        if response_format == "object":
+            return {"assistants": assistants, "next": next_cursor}
+        return assistants
+
+    async def count(
+        self,
+        *,
+        metadata: Json = None,
+        graph_id: str | None = None,
+        name: str | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> int:
+        """Count assistants matching filters.
+
+        Args:
+            metadata: Metadata to filter by. Exact match for each key/value.
+            graph_id: Optional graph id to filter by.
+            name: Optional name to filter by.
+                The filtering logic will match assistants where 'name' is a substring (case insensitive) of the assistant name.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            int: Number of assistants matching the criteria.
+        """
+        payload: dict[str, Any] = {}
+        if metadata:
+            payload["metadata"] = metadata
+        if graph_id:
+            payload["graph_id"] = graph_id
+        if name:
+            payload["name"] = name
+        return await self.http.post(
+            "/assistants/count", json=payload, headers=headers, params=params
+        )
+
+    async def get_versions(
+        self,
+        assistant_id: str,
+        metadata: Json = None,
+        limit: int = 10,
+        offset: int = 0,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> list[AssistantVersion]:
+        """List all versions of an assistant.
+
+        Args:
+            assistant_id: The assistant ID to get versions for.
+            metadata: Metadata to filter versions by. Exact match filter for each KV pair.
+            limit: The maximum number of versions to return.
+            offset: The number of versions to skip.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            A list of assistant versions.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            assistant_versions = await client.assistants.get_versions(
+                assistant_id="my_assistant_id"
+            )
+            ```
+        """
+
+        payload: dict[str, Any] = {
+            "limit": limit,
+            "offset": offset,
+        }
+        if metadata:
+            payload["metadata"] = metadata
+        return await self.http.post(
+            f"/assistants/{assistant_id}/versions",
+            json=payload,
+            headers=headers,
+            params=params,
+        )
+
+    async def set_latest(
+        self,
+        assistant_id: str,
+        version: int,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Assistant:
+        """Change the version of an assistant.
+
+        Args:
+            assistant_id: The assistant ID to delete.
+            version: The version to change to.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            Assistant Object.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            new_version_assistant = await client.assistants.set_latest(
+                assistant_id="my_assistant_id",
+                version=3
+            )
+            ```
+
+        """
+
+        payload: dict[str, Any] = {"version": version}
+
+        return await self.http.post(
+            f"/assistants/{assistant_id}/latest",
+            json=payload,
+            headers=headers,
+            params=params,
+        )

libs/sdk-py/langgraph_sdk/_async/client.py

@@ -0,0 +1,178 @@
+"""Async LangGraph client."""
+
+from __future__ import annotations
+
+import logging
+import os
+from collections.abc import Mapping
+from types import TracebackType
+
+import httpx
+
+from langgraph_sdk._async.assistants import AssistantsClient
+from langgraph_sdk._async.cron import CronClient
+from langgraph_sdk._async.http import HttpClient
+from langgraph_sdk._async.runs import RunsClient
+from langgraph_sdk._async.store import StoreClient
+from langgraph_sdk._async.threads import ThreadsClient
+from langgraph_sdk._shared.types import TimeoutTypes
+from langgraph_sdk._shared.utilities import (
+    NOT_PROVIDED,
+    _get_headers,
+    _registered_transports,
+    get_asgi_transport,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def get_client(
+    *,
+    url: str | None = None,
+    api_key: str | None = NOT_PROVIDED,
+    headers: Mapping[str, str] | None = None,
+    timeout: TimeoutTypes | None = None,
+) -> LangGraphClient:
+    """Create and configure a LangGraphClient.
+
+    The client provides programmatic access to LangSmith Deployment. It supports
+    both remote servers and local in-process connections (when running inside a LangGraph server).
+
+    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 defers registration until after app initialization. This
+              only works if the client is used from within the Agent server.
+        api_key:
+            API key for authentication. Can be:
+              - A string: use this exact API key
+              - `None`: explicitly skip loading from environment variables
+              - Not provided (default): auto-load from environment in this order:
+                1. `LANGGRAPH_API_KEY`
+                2. `LANGSMITH_API_KEY`
+                3. `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.
+
+    Returns:
+        LangGraphClient:
+            A top-level client exposing sub-clients for assistants, threads,
+            runs, and cron operations.
+
+    ???+ example "Connect to a remote server:"
+
+        ```python
+        from langgraph_sdk import get_client
+
+        # get top-level LangGraphClient
+        client = get_client(url="http://localhost:8123")
+
+        # 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"}]},
+            )
+        ```
+
+    ???+ example "Skip auto-loading API key from environment:"
+
+        ```python
+        from langgraph_sdk import get_client
+
+        # Don't load API key from environment variables
+        client = get_client(
+            url="http://localhost:8123",
+            api_key=None
+        )
+        ```
+    """
+
+    transport: httpx.AsyncBaseTransport | None = None
+    if url is None:
+        url = "http://api"
+        if os.environ.get("__LANGGRAPH_DEFER_LOOPBACK_TRANSPORT") == "true":
+            transport = get_asgi_transport()(app=None, root_path="/noauth")
+            _registered_transports.append(transport)
+        else:
+            try:
+                from langgraph_api.server import app  # type: ignore
+
+                transport = get_asgi_transport()(app, root_path="/noauth")
+            except Exception:
+                logger.debug(
+                    "Failed to connect to in-process LangGraph server. Deferring configuration.",
+                    exc_info=True,
+                )
+                transport = get_asgi_transport()(app=None, root_path="/noauth")
+                _registered_transports.append(transport)
+
+    if transport is None:
+        transport = httpx.AsyncHTTPTransport(retries=5)
+    client = httpx.AsyncClient(
+        base_url=url,
+        transport=transport,
+        timeout=(
+            httpx.Timeout(timeout)  # type: ignore[arg-type]
+            if timeout is not None
+            else httpx.Timeout(connect=5, read=300, write=300, pool=5)
+        ),
+        headers=_get_headers(api_key, headers),
+    )
+    return LangGraphClient(client)
+
+
+class LangGraphClient:
+    """Top-level client for LangGraph API.
+
+    Attributes:
+        assistants: Manages versioned configuration for your graphs.
+        threads: Handles (potentially) multi-turn interactions, such as conversational threads.
+        runs: Controls individual invocations of the graph.
+        crons: Manages scheduled operations.
+        store: Interfaces with persistent, shared data storage.
+    """
+
+    def __init__(self, client: httpx.AsyncClient) -> None:
+        self.http = HttpClient(client)
+        self.assistants = AssistantsClient(self.http)
+        self.threads = ThreadsClient(self.http)
+        self.runs = RunsClient(self.http)
+        self.crons = CronClient(self.http)
+        self.store = StoreClient(self.http)
+
+    async def __aenter__(self) -> LangGraphClient:
+        """Enter the async context manager."""
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Exit the async context manager."""
+        await self.aclose()
+
+    async def aclose(self) -> None:
+        """Close the underlying HTTP client."""
+        if hasattr(self, "http"):
+            await self.http.client.aclose()

libs/sdk-py/langgraph_sdk/_async/cron.py

@@ -0,0 +1,452 @@
+"""Async client for managing recurrent runs (cron jobs) in LangGraph."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from datetime import datetime
+from typing import Any
+
+from langgraph_sdk._async.http import HttpClient
+from langgraph_sdk.schema import (
+    All,
+    Config,
+    Context,
+    Cron,
+    CronSelectField,
+    CronSortBy,
+    Input,
+    OnCompletionBehavior,
+    QueryParamTypes,
+    Run,
+    SortOrder,
+)
+
+
+class CronClient:
+    """Client for managing recurrent runs (cron jobs) in LangGraph.
+
+    A run is a single invocation of an assistant with optional input, config, and context.
+    This client allows scheduling recurring runs to occur automatically.
+
+    ???+ example "Example Usage"
+
+        ```python
+        client = get_client(url="http://localhost:2024"))
+        cron_job = await client.crons.create_for_thread(
+            thread_id="thread_123",
+            assistant_id="asst_456",
+            schedule="0 9 * * *",
+            input={"message": "Daily update"}
+        )
+        ```
+
+    !!! note "Feature Availability"
+
+        The crons client functionality is not supported on all licenses.
+        Please check the relevant license documentation for the most up-to-date
+        details on feature availability.
+    """
+
+    def __init__(self, http_client: HttpClient) -> None:
+        self.http = http_client
+
+    async def create_for_thread(
+        self,
+        thread_id: str,
+        assistant_id: str,
+        *,
+        schedule: str,
+        input: Input | None = None,
+        metadata: Mapping[str, Any] | None = None,
+        config: Config | None = None,
+        context: Context | None = None,
+        checkpoint_during: bool | None = None,
+        interrupt_before: All | list[str] | None = None,
+        interrupt_after: All | list[str] | None = None,
+        webhook: str | None = None,
+        multitask_strategy: str | None = None,
+        end_time: datetime | None = None,
+        enabled: bool | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Run:
+        """Create a cron job for a thread.
+
+        Args:
+            thread_id: the thread ID to run the cron job on.
+            assistant_id: The assistant ID or graph name to use for the cron job.
+                If using graph name, will default to first assistant created from that graph.
+            schedule: The cron schedule to execute this job on.
+                Schedules are interpreted in UTC.
+            input: The input to the graph.
+            metadata: Metadata to assign to the cron job runs.
+            config: The configuration for the assistant.
+            context: Static context to add to the assistant.
+                !!! version-added "Added in version 0.6.0"
+            checkpoint_during: Whether to checkpoint during the run (or only at the end/interruption).
+            interrupt_before: Nodes to interrupt immediately before they get executed.
+
+            interrupt_after: Nodes to Nodes to interrupt immediately after they get executed.
+
+            webhook: Webhook to call after LangGraph API call is done.
+            multitask_strategy: Multitask strategy to use.
+                Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'.
+            end_time: The time to stop running the cron job. If not provided, the cron job will run indefinitely.
+            enabled: Whether the cron job is enabled or not.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            The cron run.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            cron_run = await client.crons.create_for_thread(
+                thread_id="my-thread-id",
+                assistant_id="agent",
+                schedule="27 15 * * *",
+                input={"messages": [{"role": "user", "content": "hello!"}]},
+                metadata={"name":"my_run"},
+                context={"model_name": "openai"},
+                interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"],
+                interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"],
+                webhook="https://my.fake.webhook.com",
+                multitask_strategy="interrupt",
+                enabled=True,
+            )
+            ```
+        """
+        payload = {
+            "schedule": schedule,
+            "input": input,
+            "config": config,
+            "metadata": metadata,
+            "context": context,
+            "assistant_id": assistant_id,
+            "checkpoint_during": checkpoint_during,
+            "interrupt_before": interrupt_before,
+            "interrupt_after": interrupt_after,
+            "webhook": webhook,
+            "end_time": end_time.isoformat() if end_time else None,
+            "enabled": enabled,
+        }
+        if multitask_strategy:
+            payload["multitask_strategy"] = multitask_strategy
+        payload = {k: v for k, v in payload.items() if v is not None}
+        return await self.http.post(
+            f"/threads/{thread_id}/runs/crons",
+            json=payload,
+            headers=headers,
+            params=params,
+        )
+
+    async def create(
+        self,
+        assistant_id: str,
+        *,
+        schedule: str,
+        input: Input | None = None,
+        metadata: Mapping[str, Any] | None = None,
+        config: Config | None = None,
+        context: Context | None = None,
+        checkpoint_during: bool | None = None,
+        interrupt_before: All | list[str] | None = None,
+        interrupt_after: All | list[str] | None = None,
+        webhook: str | None = None,
+        on_run_completed: OnCompletionBehavior | None = None,
+        multitask_strategy: str | None = None,
+        end_time: datetime | None = None,
+        enabled: bool | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Run:
+        """Create a cron run.
+
+        Args:
+            assistant_id: The assistant ID or graph name to use for the cron job.
+                If using graph name, will default to first assistant created from that graph.
+            schedule: The cron schedule to execute this job on.
+                Schedules are interpreted in UTC.
+            input: The input to the graph.
+            metadata: Metadata to assign to the cron job runs.
+            config: The configuration for the assistant.
+            context: Static context to add to the assistant.
+                !!! version-added "Added in version 0.6.0"
+            checkpoint_during: Whether to checkpoint during the run (or only at the end/interruption).
+            interrupt_before: Nodes to interrupt immediately before they get executed.
+            interrupt_after: Nodes to Nodes to interrupt immediately after they get executed.
+            webhook: Webhook to call after LangGraph API call is done.
+            on_run_completed: What to do with the thread after the run completes.
+                Must be one of 'delete' (default) or 'keep'. 'delete' removes the thread
+                after execution. 'keep' creates a new thread for each execution but does not
+                clean them up. Clients are responsible for cleaning up kept threads.
+            multitask_strategy: Multitask strategy to use.
+                Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'.
+            end_time: The time to stop running the cron job. If not provided, the cron job will run indefinitely.
+            enabled: Whether the cron job is enabled or not.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            The cron run.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            cron_run = client.crons.create(
+                assistant_id="agent",
+                schedule="27 15 * * *",
+                input={"messages": [{"role": "user", "content": "hello!"}]},
+                metadata={"name":"my_run"},
+                context={"model_name": "openai"},
+                interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"],
+                interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"],
+                webhook="https://my.fake.webhook.com",
+                multitask_strategy="interrupt",
+                enabled=True,
+            )
+            ```
+
+        """
+        payload = {
+            "schedule": schedule,
+            "input": input,
+            "config": config,
+            "metadata": metadata,
+            "context": context,
+            "assistant_id": assistant_id,
+            "checkpoint_during": checkpoint_during,
+            "interrupt_before": interrupt_before,
+            "interrupt_after": interrupt_after,
+            "webhook": webhook,
+            "on_run_completed": on_run_completed,
+            "end_time": end_time.isoformat() if end_time else None,
+            "enabled": enabled,
+        }
+        if multitask_strategy:
+            payload["multitask_strategy"] = multitask_strategy
+        payload = {k: v for k, v in payload.items() if v is not None}
+        return await self.http.post(
+            "/runs/crons", json=payload, headers=headers, params=params
+        )
+
+    async def delete(
+        self,
+        cron_id: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None:
+        """Delete a cron.
+
+        Args:
+            cron_id: The cron ID to delete.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            await client.crons.delete(
+                cron_id="cron_to_delete"
+            )
+            ```
+
+        """
+        await self.http.delete(f"/runs/crons/{cron_id}", headers=headers, params=params)
+
+    async def update(
+        self,
+        cron_id: str,
+        *,
+        schedule: str | None = None,
+        end_time: datetime | None = None,
+        input: Input | None = None,
+        metadata: Mapping[str, Any] | None = None,
+        config: Config | None = None,
+        context: Context | None = None,
+        webhook: str | None = None,
+        interrupt_before: All | list[str] | None = None,
+        interrupt_after: All | list[str] | None = None,
+        on_run_completed: OnCompletionBehavior | None = None,
+        enabled: bool | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Cron:
+        """Update a cron job by ID.
+
+        Args:
+            cron_id: The cron ID to update.
+            schedule: The cron schedule to execute this job on.
+                Schedules are interpreted in UTC.
+            end_time: The end date to stop running the cron.
+            input: The input to the graph.
+            metadata: Metadata to assign to the cron job runs.
+            config: The configuration for the assistant.
+            context: Static context added to the assistant.
+            webhook: Webhook to call after LangGraph API call is done.
+            interrupt_before: Nodes to interrupt immediately before they get executed.
+            interrupt_after: Nodes to interrupt immediately after they get executed.
+            on_run_completed: What to do with the thread after the run completes.
+                Must be one of 'delete' or 'keep'. 'delete' removes the thread
+                after execution. 'keep' creates a new thread for each execution but does not
+                clean them up.
+            enabled: Enable or disable the cron job.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            The updated cron job.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            updated_cron = await client.crons.update(
+                cron_id="1ef3cefa-4c09-6926-96d0-3dc97fd5e39b",
+                schedule="0 10 * * *",
+                enabled=False,
+            )
+            ```
+
+        """
+        payload = {
+            "schedule": schedule,
+            "end_time": end_time.isoformat() if end_time else None,
+            "input": input,
+            "metadata": metadata,
+            "config": config,
+            "context": context,
+            "webhook": webhook,
+            "interrupt_before": interrupt_before,
+            "interrupt_after": interrupt_after,
+            "on_run_completed": on_run_completed,
+            "enabled": enabled,
+        }
+        payload = {k: v for k, v in payload.items() if v is not None}
+        return await self.http.patch(
+            f"/runs/crons/{cron_id}",
+            json=payload,
+            headers=headers,
+            params=params,
+        )
+
+    async def search(
+        self,
+        *,
+        assistant_id: str | None = None,
+        thread_id: str | None = None,
+        enabled: bool | None = None,
+        limit: int = 10,
+        offset: int = 0,
+        sort_by: CronSortBy | None = None,
+        sort_order: SortOrder | None = None,
+        select: list[CronSelectField] | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> list[Cron]:
+        """Get a list of cron jobs.
+
+        Args:
+            assistant_id: The assistant ID or graph name to search for.
+            thread_id: the thread ID to search for.
+            enabled: The enabled status to search for.
+            limit: The maximum number of results to return.
+            offset: The number of results to skip.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            The list of cron jobs returned by the search,
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            cron_jobs = await client.crons.search(
+                assistant_id="my_assistant_id",
+                thread_id="my_thread_id",
+                enabled=True,
+                limit=5,
+                offset=5,
+            )
+            print(cron_jobs)
+            ```
+            ```shell
+
+            ----------------------------------------------------------
+
+            [
+                {
+                    'cron_id': '1ef3cefa-4c09-6926-96d0-3dc97fd5e39b',
+                    'assistant_id': 'my_assistant_id',
+                    'thread_id': 'my_thread_id',
+                    'user_id': None,
+                    'payload':
+                        {
+                            'input': {'start_time': ''},
+                            'schedule': '4 * * * *',
+                            'assistant_id': 'my_assistant_id'
+                        },
+                    'schedule': '4 * * * *',
+                    'next_run_date': '2024-07-25T17:04:00+00:00',
+                    'end_time': None,
+                    'created_at': '2024-07-08T06:02:23.073257+00:00',
+                    'updated_at': '2024-07-08T06:02:23.073257+00:00'
+                }
+            ]
+            ```
+
+        """
+        payload = {
+            "assistant_id": assistant_id,
+            "thread_id": thread_id,
+            "enabled": enabled,
+            "limit": limit,
+            "offset": offset,
+        }
+        if sort_by:
+            payload["sort_by"] = sort_by
+        if sort_order:
+            payload["sort_order"] = sort_order
+        if select:
+            payload["select"] = select
+        payload = {k: v for k, v in payload.items() if v is not None}
+        return await self.http.post(
+            "/runs/crons/search", json=payload, headers=headers, params=params
+        )
+
+    async def count(
+        self,
+        *,
+        assistant_id: str | None = None,
+        thread_id: str | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> int:
+        """Count cron jobs matching filters.
+
+        Args:
+            assistant_id: Assistant ID to filter by.
+            thread_id: Thread ID to filter by.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            int: Number of crons matching the criteria.
+        """
+        payload: dict[str, Any] = {}
+        if assistant_id:
+            payload["assistant_id"] = assistant_id
+        if thread_id:
+            payload["thread_id"] = thread_id
+        return await self.http.post(
+            "/runs/crons/count", json=payload, headers=headers, params=params
+        )

libs/sdk-py/langgraph_sdk/_async/http.py

@@ -0,0 +1,305 @@
+"""HTTP client for async operations."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import sys
+import warnings
+from collections.abc import AsyncIterator, Callable, Mapping
+from typing import Any, cast
+
+import httpx
+import orjson
+
+from langgraph_sdk._shared.utilities import _orjson_default
+from langgraph_sdk.errors import _araise_for_status_typed
+from langgraph_sdk.schema import QueryParamTypes, StreamPart
+from langgraph_sdk.sse import SSEDecoder, aiter_lines_raw
+
+logger = logging.getLogger(__name__)
+
+
+class HttpClient:
+    """Handle async requests to the LangGraph API.
+
+    Adds additional error messaging & content handling above the
+    provided httpx client.
+
+    Attributes:
+        client (httpx.AsyncClient): Underlying HTTPX async client.
+    """
+
+    def __init__(self, client: httpx.AsyncClient) -> None:
+        self.client = client
+
+    async def get(
+        self,
+        path: str,
+        *,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+    ) -> Any:
+        """Send a `GET` request."""
+        r = await self.client.get(path, params=params, headers=headers)
+        if on_response:
+            on_response(r)
+        await _araise_for_status_typed(r)
+        return await _adecode_json(r)
+
+    async def post(
+        self,
+        path: str,
+        *,
+        json: dict[str, Any] | list | None,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+    ) -> Any:
+        """Send a `POST` request."""
+        if json is not None:
+            request_headers, content = await _aencode_json(json)
+        else:
+            request_headers, content = {}, b""
+        # Merge headers, with runtime headers taking precedence
+        if headers:
+            request_headers.update(headers)
+        r = await self.client.post(
+            path, headers=request_headers, content=content, params=params
+        )
+        if on_response:
+            on_response(r)
+        await _araise_for_status_typed(r)
+        return await _adecode_json(r)
+
+    async def put(
+        self,
+        path: str,
+        *,
+        json: dict,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+    ) -> Any:
+        """Send a `PUT` request."""
+        request_headers, content = await _aencode_json(json)
+        if headers:
+            request_headers.update(headers)
+        r = await self.client.put(
+            path, headers=request_headers, content=content, params=params
+        )
+        if on_response:
+            on_response(r)
+        await _araise_for_status_typed(r)
+        return await _adecode_json(r)
+
+    async def patch(
+        self,
+        path: str,
+        *,
+        json: dict,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+    ) -> Any:
+        """Send a `PATCH` request."""
+        request_headers, content = await _aencode_json(json)
+        if headers:
+            request_headers.update(headers)
+        r = await self.client.patch(
+            path, headers=request_headers, content=content, params=params
+        )
+        if on_response:
+            on_response(r)
+        await _araise_for_status_typed(r)
+        return await _adecode_json(r)
+
+    async def delete(
+        self,
+        path: str,
+        *,
+        json: Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+    ) -> None:
+        """Send a `DELETE` request."""
+        r = await self.client.request(
+            "DELETE", path, json=json, params=params, headers=headers
+        )
+        if on_response:
+            on_response(r)
+        await _araise_for_status_typed(r)
+
+    async def request_reconnect(
+        self,
+        path: str,
+        method: str,
+        *,
+        json: dict[str, Any] | None = None,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+        reconnect_limit: int = 5,
+    ) -> Any:
+        """Send a request that automatically reconnects to Location header."""
+        request_headers, content = await _aencode_json(json)
+        if headers:
+            request_headers.update(headers)
+        async with self.client.stream(
+            method, path, headers=request_headers, content=content, params=params
+        ) as r:
+            if on_response:
+                on_response(r)
+            try:
+                r.raise_for_status()
+            except httpx.HTTPStatusError as e:
+                body = (await r.aread()).decode()
+                if sys.version_info >= (3, 11):
+                    e.add_note(body)
+                else:
+                    logger.error(f"Error from langgraph-api: {body}", exc_info=e)
+                raise e
+            loc = r.headers.get("location")
+            if reconnect_limit <= 0 or not loc:
+                return await _adecode_json(r)
+            try:
+                return await _adecode_json(r)
+            except httpx.HTTPError:
+                warnings.warn(
+                    f"Request failed, attempting reconnect to Location: {loc}",
+                    stacklevel=2,
+                )
+                await r.aclose()
+                return await self.request_reconnect(
+                    loc,
+                    "GET",
+                    headers=request_headers,
+                    # don't pass on_response so it's only called once
+                    reconnect_limit=reconnect_limit - 1,
+                )
+
+    async def stream(
+        self,
+        path: str,
+        method: str,
+        *,
+        json: dict[str, Any] | None = None,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+    ) -> AsyncIterator[StreamPart]:
+        """Stream results using SSE."""
+        request_headers, content = await _aencode_json(json)
+        request_headers["Accept"] = "text/event-stream"
+        request_headers["Cache-Control"] = "no-store"
+        # Add runtime headers with precedence
+        if headers:
+            request_headers.update(headers)
+
+        reconnect_headers = {
+            key: value
+            for key, value in request_headers.items()
+            if key.lower() not in {"content-length", "content-type"}
+        }
+
+        last_event_id: str | None = None
+        reconnect_path: str | None = None
+        reconnect_attempts = 0
+        max_reconnect_attempts = 5
+
+        while True:
+            current_headers = dict(
+                request_headers if reconnect_path is None else reconnect_headers
+            )
+            if last_event_id is not None:
+                current_headers["Last-Event-ID"] = last_event_id
+
+            current_method = method if reconnect_path is None else "GET"
+            current_content = content if reconnect_path is None else None
+            current_params = params if reconnect_path is None else None
+
+            retry = False
+            async with self.client.stream(
+                current_method,
+                reconnect_path or path,
+                headers=current_headers,
+                content=current_content,
+                params=current_params,
+            ) as res:
+                if reconnect_path is None and on_response:
+                    on_response(res)
+                # check status
+                await _araise_for_status_typed(res)
+                # check content type
+                content_type = res.headers.get("content-type", "").partition(";")[0]
+                if "text/event-stream" not in content_type:
+                    raise httpx.TransportError(
+                        "Expected response header Content-Type to contain 'text/event-stream', "
+                        f"got {content_type!r}"
+                    )
+
+                reconnect_location = res.headers.get("location")
+                if reconnect_location:
+                    reconnect_path = reconnect_location
+
+                # parse SSE
+                decoder = SSEDecoder()
+                try:
+                    async for line in aiter_lines_raw(res):
+                        sse = decoder.decode(line=cast("bytes", line).rstrip(b"\n"))
+                        if sse is not None:
+                            if decoder.last_event_id is not None:
+                                last_event_id = decoder.last_event_id
+                            if sse.event or sse.data is not None:
+                                yield sse
+                except httpx.HTTPError:
+                    # httpx.TransportError inherits from HTTPError, so transient
+                    # disconnects during streaming land here.
+                    if reconnect_path is None:
+                        raise
+                    retry = True
+                else:
+                    if sse := decoder.decode(b""):
+                        if decoder.last_event_id is not None:
+                            last_event_id = decoder.last_event_id
+                        if sse.event or sse.data is not None:
+                            # decoder.decode(b"") flushes the in-flight event and may
+                            # return an empty placeholder when there is no pending
+                            # message. Skip these no-op events so the stream doesn't
+                            # emit a trailing blank item after reconnects.
+                            yield sse
+            if retry:
+                reconnect_attempts += 1
+                if reconnect_attempts > max_reconnect_attempts:
+                    raise httpx.TransportError(
+                        "Exceeded maximum SSE reconnection attempts"
+                    )
+                continue
+            break
+
+
+async def _aencode_json(json: Any) -> tuple[dict[str, str], bytes | None]:
+    if json is None:
+        return {}, None
+    body = await asyncio.get_running_loop().run_in_executor(
+        None,
+        orjson.dumps,
+        json,
+        _orjson_default,
+        orjson.OPT_SERIALIZE_NUMPY | orjson.OPT_NON_STR_KEYS,
+    )
+    content_length = str(len(body))
+    content_type = "application/json"
+    headers = {"Content-Length": content_length, "Content-Type": content_type}
+    return headers, body
+
+
+async def _adecode_json(r: httpx.Response) -> Any:
+    body = await r.aread()
+    return (
+        await asyncio.get_running_loop().run_in_executor(None, orjson.loads, body)
+        if body
+        else None
+    )

libs/sdk-py/langgraph_sdk/_async/store.py

@@ -0,0 +1,313 @@
+"""Async Store client for LangGraph SDK."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import Any, Literal
+
+from langgraph_sdk._async.http import HttpClient
+from langgraph_sdk._shared.utilities import _provided_vals
+from langgraph_sdk.schema import (
+    Item,
+    ListNamespaceResponse,
+    QueryParamTypes,
+    SearchItemsResponse,
+)
+
+
+class StoreClient:
+    """Client for interacting with the graph's shared storage.
+
+    The Store provides a key-value storage system for persisting data across graph executions,
+    allowing for stateful operations and data sharing across threads.
+
+    ???+ example "Example"
+
+        ```python
+        client = get_client(url="http://localhost:2024")
+        await client.store.put_item(["users", "user123"], "mem-123451342", {"name": "Alice", "score": 100})
+        ```
+    """
+
+    def __init__(self, http: HttpClient) -> None:
+        self.http = http
+
+    async def put_item(
+        self,
+        namespace: Sequence[str],
+        /,
+        key: str,
+        value: Mapping[str, Any],
+        index: Literal[False] | list[str] | None = None,
+        ttl: int | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None:
+        """Store or update an item.
+
+        Args:
+            namespace: A list of strings representing the namespace path.
+            key: The unique identifier for the item within the namespace.
+            value: A dictionary containing the item's data.
+            index: Controls search indexing - None (use defaults), False (disable), or list of field paths to index.
+            ttl: Optional time-to-live in minutes for the item, or None for no expiration.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            await client.store.put_item(
+                ["documents", "user123"],
+                key="item456",
+                value={"title": "My Document", "content": "Hello World"}
+            )
+            ```
+        """
+        for label in namespace:
+            if "." in label:
+                raise ValueError(
+                    f"Invalid namespace label '{label}'. Namespace labels cannot contain periods ('.')."
+                )
+        payload = {
+            "namespace": namespace,
+            "key": key,
+            "value": value,
+            "index": index,
+            "ttl": ttl,
+        }
+        await self.http.put(
+            "/store/items", json=_provided_vals(payload), headers=headers, params=params
+        )
+
+    async def get_item(
+        self,
+        namespace: Sequence[str],
+        /,
+        key: str,
+        *,
+        refresh_ttl: bool | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Item:
+        """Retrieve a single item.
+
+        Args:
+            key: The unique identifier for the item.
+            namespace: Optional list of strings representing the namespace path.
+            refresh_ttl: Whether to refresh the TTL on this read operation. If `None`, uses the store's default behavior.
+
+        Returns:
+            Item: The retrieved item.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            item = await client.store.get_item(
+                ["documents", "user123"],
+                key="item456",
+            )
+            print(item)
+            ```
+            ```shell
+
+            ----------------------------------------------------------------
+
+            {
+                'namespace': ['documents', 'user123'],
+                'key': 'item456',
+                'value': {'title': 'My Document', 'content': 'Hello World'},
+                'created_at': '2024-07-30T12:00:00Z',
+                'updated_at': '2024-07-30T12:00:00Z'
+            }
+            ```
+        """
+        for label in namespace:
+            if "." in label:
+                raise ValueError(
+                    f"Invalid namespace label '{label}'. Namespace labels cannot contain periods ('.')."
+                )
+        get_params = {"namespace": ".".join(namespace), "key": key}
+        if refresh_ttl is not None:
+            get_params["refresh_ttl"] = refresh_ttl
+        if params:
+            get_params = {**get_params, **params}
+        return await self.http.get("/store/items", params=get_params, headers=headers)
+
+    async def delete_item(
+        self,
+        namespace: Sequence[str],
+        /,
+        key: str,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None:
+        """Delete an item.
+
+        Args:
+            key: The unique identifier for the item.
+            namespace: Optional list of strings representing the namespace path.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            await client.store.delete_item(
+                ["documents", "user123"],
+                key="item456",
+            )
+            ```
+        """
+        await self.http.delete(
+            "/store/items",
+            json={"namespace": namespace, "key": key},
+            headers=headers,
+            params=params,
+        )
+
+    async def search_items(
+        self,
+        namespace_prefix: Sequence[str],
+        /,
+        filter: Mapping[str, Any] | None = None,
+        limit: int = 10,
+        offset: int = 0,
+        query: str | None = None,
+        refresh_ttl: bool | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> SearchItemsResponse:
+        """Search for items within a namespace prefix.
+
+        Args:
+            namespace_prefix: List of strings representing the namespace prefix.
+            filter: Optional dictionary of key-value pairs to filter results.
+            limit: Maximum number of items to return (default is 10).
+            offset: Number of items to skip before returning results (default is 0).
+            query: Optional query for natural language search.
+            refresh_ttl: Whether to refresh the TTL on items returned by this search. If `None`, uses the store's default behavior.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            A list of items matching the search criteria.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            items = await client.store.search_items(
+                ["documents"],
+                filter={"author": "John Doe"},
+                limit=5,
+                offset=0
+            )
+            print(items)
+            ```
+            ```shell
+
+            ----------------------------------------------------------------
+
+            {
+                "items": [
+                    {
+                        "namespace": ["documents", "user123"],
+                        "key": "item789",
+                        "value": {
+                            "title": "Another Document",
+                            "author": "John Doe"
+                        },
+                        "created_at": "2024-07-30T12:00:00Z",
+                        "updated_at": "2024-07-30T12:00:00Z"
+                    },
+                    # ... additional items ...
+                ]
+            }
+            ```
+        """
+        payload = {
+            "namespace_prefix": namespace_prefix,
+            "filter": filter,
+            "limit": limit,
+            "offset": offset,
+            "query": query,
+            "refresh_ttl": refresh_ttl,
+        }
+
+        return await self.http.post(
+            "/store/items/search",
+            json=_provided_vals(payload),
+            headers=headers,
+            params=params,
+        )
+
+    async def list_namespaces(
+        self,
+        prefix: list[str] | None = None,
+        suffix: list[str] | None = None,
+        max_depth: int | None = None,
+        limit: int = 100,
+        offset: int = 0,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> ListNamespaceResponse:
+        """List namespaces with optional match conditions.
+
+        Args:
+            prefix: Optional list of strings representing the prefix to filter namespaces.
+            suffix: Optional list of strings representing the suffix to filter namespaces.
+            max_depth: Optional integer specifying the maximum depth of namespaces to return.
+            limit: Maximum number of namespaces to return (default is 100).
+            offset: Number of namespaces to skip before returning results (default is 0).
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            A list of namespaces matching the criteria.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            namespaces = await client.store.list_namespaces(
+                prefix=["documents"],
+                max_depth=3,
+                limit=10,
+                offset=0
+            )
+            print(namespaces)
+
+            ----------------------------------------------------------------
+
+            [
+                ["documents", "user123", "reports"],
+                ["documents", "user456", "invoices"],
+                ...
+            ]
+            ```
+        """
+        payload = {
+            "prefix": prefix,
+            "suffix": suffix,
+            "max_depth": max_depth,
+            "limit": limit,
+            "offset": offset,
+        }
+        return await self.http.post(
+            "/store/namespaces",
+            json=_provided_vals(payload),
+            headers=headers,
+            params=params,
+        )

libs/sdk-py/langgraph_sdk/_async/threads.py

@@ -0,0 +1,722 @@
+"""Async client for managing threads in LangGraph."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Mapping, Sequence
+from typing import Any
+
+from langgraph_sdk._async.http import HttpClient
+from langgraph_sdk.schema import (
+    Checkpoint,
+    Json,
+    OnConflictBehavior,
+    PruneStrategy,
+    QueryParamTypes,
+    SortOrder,
+    StreamPart,
+    Thread,
+    ThreadSelectField,
+    ThreadSortBy,
+    ThreadState,
+    ThreadStatus,
+    ThreadStreamMode,
+    ThreadUpdateStateResponse,
+)
+
+
+class ThreadsClient:
+    """Client for managing threads in LangGraph.
+
+    A thread maintains the state of a graph across multiple interactions/invocations (aka runs).
+    It accumulates and persists the graph's state, allowing for continuity between separate
+    invocations of the graph.
+
+    ???+ example "Example"
+
+        ```python
+        client = get_client(url="http://localhost:2024"))
+        new_thread = await client.threads.create(metadata={"user_id": "123"})
+        ```
+    """
+
+    def __init__(self, http: HttpClient) -> None:
+        self.http = http
+
+    async def get(
+        self,
+        thread_id: str,
+        *,
+        include: Sequence[str] | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Thread:
+        """Get a thread by ID.
+
+        Args:
+            thread_id: The ID of the thread to get.
+            include: Additional fields to include in the response.
+                Supported values: `"ttl"`.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            Thread object.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            thread = await client.threads.get(
+                thread_id="my_thread_id"
+            )
+            print(thread)
+            ```
+
+            ```shell
+            -----------------------------------------------------
+
+            {
+                'thread_id': 'my_thread_id',
+                'created_at': '2024-07-18T18:35:15.540834+00:00',
+                'updated_at': '2024-07-18T18:35:15.540834+00:00',
+                'metadata': {'graph_id': 'agent'}
+            }
+            ```
+
+        """
+        query_params: dict[str, Any] = {}
+        if include:
+            query_params["include"] = ",".join(include)
+        if params:
+            query_params.update(params)
+        return await self.http.get(
+            f"/threads/{thread_id}",
+            headers=headers,
+            params=query_params or None,
+        )
+
+    async def create(
+        self,
+        *,
+        metadata: Json = None,
+        thread_id: str | None = None,
+        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:
+        """Create a new thread.
+
+        Args:
+            metadata: Metadata to add to thread.
+            thread_id: ID of thread.
+                If `None`, ID will be a randomly generated UUID.
+            if_exists: How to handle duplicate creation. Defaults to 'raise' under the hood.
+                Must be either 'raise' (raise error if duplicate), or 'do_nothing' (return existing thread).
+            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.
+
+        Returns:
+            The created thread.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            thread = await client.threads.create(
+                metadata={"number":1},
+                thread_id="my-thread-id",
+                if_exists="raise"
+            )
+            ```
+        """
+        payload: dict[str, Any] = {}
+        if thread_id:
+            payload["thread_id"] = thread_id
+        if metadata or graph_id:
+            payload["metadata"] = {
+                **(metadata or {}),
+                **({"graph_id": graph_id} if graph_id else {}),
+            }
+        if if_exists:
+            payload["if_exists"] = if_exists
+        if supersteps:
+            payload["supersteps"] = [
+                {
+                    "updates": [
+                        {
+                            "values": u["values"],
+                            "command": u.get("command"),
+                            "as_node": u["as_node"],
+                        }
+                        for u in s["updates"]
+                    ]
+                }
+                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
+        )
+
+    async def update(
+        self,
+        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:
+        """Update a thread.
+
+        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:
+            The created thread.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            thread = await client.threads.update(
+                thread_id="my-thread-id",
+                metadata={"number":1},
+                ttl=43_200,
+            )
+            ```
+        """
+        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,
+            headers=headers,
+            params=params,
+        )
+
+    async def delete(
+        self,
+        thread_id: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None:
+        """Delete a thread.
+
+        Args:
+            thread_id: The ID of the thread to delete.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost2024)
+            await client.threads.delete(
+                thread_id="my_thread_id"
+            )
+            ```
+
+        """
+        await self.http.delete(f"/threads/{thread_id}", headers=headers, params=params)
+
+    async def search(
+        self,
+        *,
+        metadata: Json = None,
+        values: Json = None,
+        ids: Sequence[str] | None = None,
+        status: ThreadStatus | None = None,
+        limit: int = 10,
+        offset: int = 0,
+        sort_by: ThreadSortBy | None = None,
+        sort_order: SortOrder | None = None,
+        select: list[ThreadSelectField] | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> list[Thread]:
+        """Search for threads.
+
+        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.
+            offset: Offset in threads table to start search from.
+            sort_by: Sort by field.
+            sort_order: Sort order.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            List of the threads matching the search parameters.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            threads = await client.threads.search(
+                metadata={"number":1},
+                status="interrupted",
+                limit=15,
+                offset=5
+            )
+            ```
+
+        """
+        payload: dict[str, Any] = {
+            "limit": limit,
+            "offset": offset,
+        }
+        if metadata:
+            payload["metadata"] = metadata
+        if values:
+            payload["values"] = values
+        if ids:
+            payload["ids"] = ids
+        if status:
+            payload["status"] = status
+        if sort_by:
+            payload["sort_by"] = sort_by
+        if sort_order:
+            payload["sort_order"] = sort_order
+        if select:
+            payload["select"] = select
+        return await self.http.post(
+            "/threads/search",
+            json=payload,
+            headers=headers,
+            params=params,
+        )
+
+    async def count(
+        self,
+        *,
+        metadata: Json = None,
+        values: Json = None,
+        status: ThreadStatus | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> int:
+        """Count threads matching filters.
+
+        Args:
+            metadata: Thread metadata to filter on.
+            values: State values to filter on.
+            status: Thread status to filter on.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            int: Number of threads matching the criteria.
+        """
+        payload: dict[str, Any] = {}
+        if metadata:
+            payload["metadata"] = metadata
+        if values:
+            payload["values"] = values
+        if status:
+            payload["status"] = status
+        return await self.http.post(
+            "/threads/count", json=payload, headers=headers, params=params
+        )
+
+    async def copy(
+        self,
+        thread_id: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None:
+        """Copy a thread.
+
+        Args:
+            thread_id: The ID of the thread to copy.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024)
+            await client.threads.copy(
+                thread_id="my_thread_id"
+            )
+            ```
+
+        """
+        return await self.http.post(
+            f"/threads/{thread_id}/copy", json=None, headers=headers, params=params
+        )
+
+    async def prune(
+        self,
+        thread_ids: Sequence[str],
+        *,
+        strategy: PruneStrategy = "delete",
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> dict[str, Any]:
+        """Prune threads by ID.
+
+        Args:
+            thread_ids: List of thread IDs to prune.
+            strategy: The prune strategy. `"delete"` removes threads entirely.
+                `"keep_latest"` prunes old checkpoints but keeps threads and their
+                latest state. Defaults to `"delete"`.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            A dict containing `pruned_count` (number of threads pruned).
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            result = await client.threads.prune(
+                thread_ids=["thread_1", "thread_2"],
+            )
+            print(result)  # {'pruned_count': 2}
+            ```
+
+        """
+        payload: dict[str, Any] = {
+            "thread_ids": thread_ids,
+        }
+        if strategy != "delete":
+            payload["strategy"] = strategy
+        return await self.http.post(
+            "/threads/prune", json=payload, headers=headers, params=params
+        )
+
+    async def get_state(
+        self,
+        thread_id: str,
+        checkpoint: Checkpoint | None = None,
+        checkpoint_id: str | None = None,  # deprecated
+        *,
+        subgraphs: bool = False,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> ThreadState:
+        """Get the state of a thread.
+
+        Args:
+            thread_id: The ID of the thread to get the state of.
+            checkpoint: The checkpoint to get the state of.
+            checkpoint_id: (deprecated) The checkpoint ID to get the state of.
+            subgraphs: Include subgraphs states.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            The thread of the state.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024)
+            thread_state = await client.threads.get_state(
+                thread_id="my_thread_id",
+                checkpoint_id="my_checkpoint_id"
+            )
+            print(thread_state)
+            ```
+
+            ```shell
+            ----------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+            {
+                'values': {
+                    'messages': [
+                        {
+                            'content': 'how are you?',
+                            'additional_kwargs': {},
+                            'response_metadata': {},
+                            'type': 'human',
+                            'name': None,
+                            'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10',
+                            'example': False
+                        },
+                        {
+                            'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.",
+                            'additional_kwargs': {},
+                            'response_metadata': {},
+                            'type': 'ai',
+                            'name': None,
+                            'id': 'run-159b782c-b679-4830-83c6-cef87798fe8b',
+                            'example': False,
+                            'tool_calls': [],
+                            'invalid_tool_calls': [],
+                            'usage_metadata': None
+                        }
+                    ]
+                },
+                'next': [],
+                'checkpoint':
+                    {
+                        'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2',
+                        'checkpoint_ns': '',
+                        'checkpoint_id': '1ef4a9b8-e6fb-67b1-8001-abd5184439d1'
+                    }
+                'metadata':
+                    {
+                        'step': 1,
+                        'run_id': '1ef4a9b8-d7da-679a-a45a-872054341df2',
+                        'source': 'loop',
+                        'writes':
+                            {
+                                'agent':
+                                    {
+                                        'messages': [
+                                            {
+                                                'id': 'run-159b782c-b679-4830-83c6-cef87798fe8b',
+                                                'name': None,
+                                                'type': 'ai',
+                                                'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.",
+                                                'example': False,
+                                                'tool_calls': [],
+                                                'usage_metadata': None,
+                                                'additional_kwargs': {},
+                                                'response_metadata': {},
+                                                'invalid_tool_calls': []
+                                            }
+                                        ]
+                                    }
+                            },
+                'user_id': None,
+                'graph_id': 'agent',
+                'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2',
+                'created_by': 'system',
+                'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'},
+                'created_at': '2024-07-25T15:35:44.184703+00:00',
+                'parent_config':
+                    {
+                        'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2',
+                        'checkpoint_ns': '',
+                        'checkpoint_id': '1ef4a9b8-d80d-6fa7-8000-9300467fad0f'
+                    }
+            }
+            ```
+        """
+        if checkpoint:
+            return await self.http.post(
+                f"/threads/{thread_id}/state/checkpoint",
+                json={"checkpoint": checkpoint, "subgraphs": subgraphs},
+                headers=headers,
+                params=params,
+            )
+        elif checkpoint_id:
+            get_params = {"subgraphs": subgraphs}
+            if params:
+                get_params = {**get_params, **params}
+            return await self.http.get(
+                f"/threads/{thread_id}/state/{checkpoint_id}",
+                params=get_params,
+                headers=headers,
+            )
+        else:
+            get_params = {"subgraphs": subgraphs}
+            if params:
+                get_params = {**get_params, **params}
+            return await self.http.get(
+                f"/threads/{thread_id}/state",
+                params=get_params,
+                headers=headers,
+            )
+
+    async def update_state(
+        self,
+        thread_id: str,
+        values: dict[str, Any] | Sequence[dict] | None,
+        *,
+        as_node: str | None = None,
+        checkpoint: Checkpoint | None = None,
+        checkpoint_id: str | None = None,  # deprecated
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> ThreadUpdateStateResponse:
+        """Update the state of a thread.
+
+        Args:
+            thread_id: The ID of the thread to update.
+            values: The values to update the state with.
+            as_node: Update the state as if this node had just executed.
+            checkpoint: The checkpoint to update the state of.
+            checkpoint_id: (deprecated) The checkpoint ID to update the state of.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            Response after updating a thread's state.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024)
+            response = await client.threads.update_state(
+                thread_id="my_thread_id",
+                values={"messages":[{"role": "user", "content": "hello!"}]},
+                as_node="my_node",
+            )
+            print(response)
+            ```
+            ```shell
+
+            ----------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+            {
+                'checkpoint': {
+                    'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2',
+                    'checkpoint_ns': '',
+                    'checkpoint_id': '1ef4a9b8-e6fb-67b1-8001-abd5184439d1',
+                    'checkpoint_map': {}
+                }
+            }
+            ```
+        """
+        payload: dict[str, Any] = {
+            "values": values,
+        }
+        if checkpoint_id:
+            payload["checkpoint_id"] = checkpoint_id
+        if checkpoint:
+            payload["checkpoint"] = checkpoint
+        if as_node:
+            payload["as_node"] = as_node
+        return await self.http.post(
+            f"/threads/{thread_id}/state", json=payload, headers=headers, params=params
+        )
+
+    async def get_history(
+        self,
+        thread_id: str,
+        *,
+        limit: int = 10,
+        before: str | Checkpoint | None = None,
+        metadata: Mapping[str, Any] | None = None,
+        checkpoint: Checkpoint | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> list[ThreadState]:
+        """Get the state history of a thread.
+
+        Args:
+            thread_id: The ID of the thread to get the state history for.
+            checkpoint: Return states for this subgraph. If empty defaults to root.
+            limit: The maximum number of states to return.
+            before: Return states before this checkpoint.
+            metadata: Filter states by metadata key-value pairs.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            The state history of the thread.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024)
+            thread_state = await client.threads.get_history(
+                thread_id="my_thread_id",
+                limit=5,
+            )
+            ```
+
+        """
+        payload: dict[str, Any] = {
+            "limit": limit,
+        }
+        if before:
+            payload["before"] = before
+        if metadata:
+            payload["metadata"] = metadata
+        if checkpoint:
+            payload["checkpoint"] = checkpoint
+        return await self.http.post(
+            f"/threads/{thread_id}/history",
+            json=payload,
+            headers=headers,
+            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:
+            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)
+            ```
+
+        """
+        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,
+        )

libs/sdk-py/langgraph_sdk/_shared/__init__.py

@@ -0,0 +1 @@
+"""Shared utilities for async and sync clients."""

libs/sdk-py/langgraph_sdk/_shared/types.py

@@ -0,0 +1,10 @@
+"""Type aliases and constants."""
+
+from __future__ import annotations
+
+TimeoutTypes = (
+    None
+    | float
+    | tuple[float | None, float | None]
+    | tuple[float | None, float | None, float | None, float | None]
+)

libs/sdk-py/langgraph_sdk/_shared/utilities.py

@@ -0,0 +1,131 @@
+"""Shared utility functions for async and sync clients."""
+
+from __future__ import annotations
+
+import functools
+import os
+import re
+from collections.abc import Mapping
+from typing import Any, cast
+
+import httpx
+
+import langgraph_sdk
+from langgraph_sdk.schema import RunCreateMetadata
+
+RESERVED_HEADERS = ("x-api-key",)
+
+NOT_PROVIDED = cast(None, object())
+
+
+def _get_api_key(api_key: str | None = NOT_PROVIDED) -> str | None:
+    """Get the API key from the environment.
+    Precedence:
+        1. explicit string argument
+        2. LANGGRAPH_API_KEY (if api_key not provided)
+        3. LANGSMITH_API_KEY (if api_key not provided)
+        4. LANGCHAIN_API_KEY (if api_key not provided)
+
+    Args:
+        api_key: The API key to use. Can be:
+            - A string: use this exact API key
+            - None: explicitly skip loading from environment
+            - NOT_PROVIDED (default): auto-load from environment variables
+    """
+    if isinstance(api_key, str):
+        return api_key
+    if api_key is NOT_PROVIDED:
+        # api_key is not explicitly provided, try to load from environment
+        for prefix in ["LANGGRAPH", "LANGSMITH", "LANGCHAIN"]:
+            if env := os.getenv(f"{prefix}_API_KEY"):
+                return env.strip().strip('"').strip("'")
+    # api_key is explicitly None, don't load from environment
+    return None
+
+
+def _get_headers(
+    api_key: str | None,
+    custom_headers: Mapping[str, str] | None,
+) -> dict[str, str]:
+    """Combine api_key and custom user-provided headers."""
+    custom_headers = custom_headers or {}
+    for header in RESERVED_HEADERS:
+        if header in custom_headers:
+            raise ValueError(f"Cannot set reserved header '{header}'")
+
+    headers = {
+        "User-Agent": f"langgraph-sdk-py/{langgraph_sdk.__version__}",
+        **custom_headers,
+    }
+    resolved_api_key = _get_api_key(api_key)
+    if resolved_api_key:
+        headers["x-api-key"] = resolved_api_key
+
+    return headers
+
+
+def _orjson_default(obj: Any) -> Any:
+    is_class = isinstance(obj, type)
+    if hasattr(obj, "model_dump") and callable(obj.model_dump):
+        if is_class:
+            raise TypeError(
+                f"Cannot JSON-serialize type object: {obj!r}. Did you mean to pass an instance of the object instead?"
+                f"\nReceived type: {obj!r}"
+            )
+        return obj.model_dump()
+    elif hasattr(obj, "dict") and callable(obj.dict):
+        if is_class:
+            raise TypeError(
+                f"Cannot JSON-serialize type object: {obj!r}. Did you mean to pass an instance of the object instead?"
+                f"\nReceived type: {obj!r}"
+            )
+        return obj.dict()
+    elif isinstance(obj, (set, frozenset)):
+        return list(obj)
+    else:
+        raise TypeError(f"Object of type {type(obj)} is not JSON serializable")
+
+
+# Compiled regex pattern for extracting run metadata from Content-Location header
+_RUN_METADATA_PATTERN = re.compile(
+    r"(\/threads\/(?P<thread_id>.+))?\/runs\/(?P<run_id>.+)"
+)
+
+
+def _get_run_metadata_from_response(
+    response: httpx.Response,
+) -> RunCreateMetadata | None:
+    """Extract run metadata from the response headers."""
+    if (content_location := response.headers.get("Content-Location")) and (
+        match := _RUN_METADATA_PATTERN.search(content_location)
+    ):
+        return RunCreateMetadata(
+            run_id=match.group("run_id"),
+            thread_id=match.group("thread_id") or None,
+        )
+
+    return None
+
+
+def _provided_vals(d: Mapping[str, Any]) -> dict[str, Any]:
+    return {k: v for k, v in d.items() if v is not None}
+
+
+_registered_transports: list[httpx.ASGITransport] = []
+
+
+# Do not move; this is used in the server.
+def configure_loopback_transports(app: Any) -> None:
+    for transport in _registered_transports:
+        transport.app = app
+
+
+@functools.lru_cache(maxsize=1)
+def get_asgi_transport() -> type[httpx.ASGITransport]:
+    try:
+        from langgraph_api import asgi_transport  # type: ignore[unresolved-import]
+
+        return asgi_transport.ASGITransport
+    except ImportError:
+        # Older versions of the server
+        return httpx.ASGITransport

libs/sdk-py/langgraph_sdk/_sync/__init__.py

@@ -0,0 +1,20 @@
+"""Sync client exports."""
+
+from langgraph_sdk._sync.assistants import SyncAssistantsClient
+from langgraph_sdk._sync.client import SyncLangGraphClient, get_sync_client
+from langgraph_sdk._sync.cron import SyncCronClient
+from langgraph_sdk._sync.http import SyncHttpClient
+from langgraph_sdk._sync.runs import SyncRunsClient
+from langgraph_sdk._sync.store import SyncStoreClient
+from langgraph_sdk._sync.threads import SyncThreadsClient
+
+__all__ = [
+    "SyncAssistantsClient",
+    "SyncCronClient",
+    "SyncHttpClient",
+    "SyncLangGraphClient",
+    "SyncRunsClient",
+    "SyncStoreClient",
+    "SyncThreadsClient",
+    "get_sync_client",
+]

libs/sdk-py/langgraph_sdk/_sync/assistants.py

@@ -0,0 +1,731 @@
+"""Synchronous client for managing assistants in LangGraph."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Literal, cast, overload
+
+import httpx
+
+from langgraph_sdk._sync.http import SyncHttpClient
+from langgraph_sdk.schema import (
+    Assistant,
+    AssistantSelectField,
+    AssistantSortBy,
+    AssistantsSearchResponse,
+    AssistantVersion,
+    Config,
+    Context,
+    GraphSchema,
+    Json,
+    OnConflictBehavior,
+    QueryParamTypes,
+    SortOrder,
+    Subgraphs,
+)
+
+
+class SyncAssistantsClient:
+    """Client for managing assistants in LangGraph synchronously.
+
+    This class provides methods to interact with assistants, which are versioned configurations of your graph.
+
+    ???+ example "Example"
+
+        ```python
+        client = get_sync_client(url="http://localhost:2024")
+        assistant = client.assistants.get("assistant_id_123")
+        ```
+    """
+
+    def __init__(self, http: SyncHttpClient) -> None:
+        self.http = http
+
+    def get(
+        self,
+        assistant_id: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Assistant:
+        """Get an assistant by ID.
+
+        Args:
+            assistant_id: The ID of the assistant to get OR the name of the graph (to use the default assistant).
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `Assistant` Object.
+
+        ???+ example "Example Usage"
+
+            ```python
+            assistant = client.assistants.get(
+                assistant_id="my_assistant_id"
+            )
+            print(assistant)
+            ```
+
+            ```shell
+            ----------------------------------------------------
+
+            {
+                'assistant_id': 'my_assistant_id',
+                'graph_id': 'agent',
+                'created_at': '2024-06-25T17:10:33.109781+00:00',
+                'updated_at': '2024-06-25T17:10:33.109781+00:00',
+                'config': {},
+                'context': {},
+                'metadata': {'created_by': 'system'}
+            }
+            ```
+
+        """
+        return self.http.get(
+            f"/assistants/{assistant_id}", headers=headers, params=params
+        )
+
+    def get_graph(
+        self,
+        assistant_id: str,
+        *,
+        xray: int | bool = False,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> dict[str, list[dict[str, Any]]]:
+        """Get the graph of an assistant by ID.
+
+        Args:
+            assistant_id: The ID of the assistant to get the graph of.
+            xray: Include graph representation of subgraphs. If an integer value is provided, only subgraphs with a depth less than or equal to the value will be included.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            The graph information for the assistant in JSON format.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            graph_info = client.assistants.get_graph(
+                assistant_id="my_assistant_id"
+            )
+            print(graph_info)
+
+            --------------------------------------------------------------------------------------------------------------------------
+
+            {
+                'nodes':
+                    [
+                        {'id': '__start__', 'type': 'schema', 'data': '__start__'},
+                        {'id': '__end__', 'type': 'schema', 'data': '__end__'},
+                        {'id': 'agent','type': 'runnable','data': {'id': ['langgraph', 'utils', 'RunnableCallable'],'name': 'agent'}},
+                    ],
+                'edges':
+                    [
+                        {'source': '__start__', 'target': 'agent'},
+                        {'source': 'agent','target': '__end__'}
+                    ]
+            }
+            ```
+
+        """
+        query_params = {"xray": xray}
+        if params:
+            query_params.update(params)
+        return self.http.get(
+            f"/assistants/{assistant_id}/graph", params=query_params, headers=headers
+        )
+
+    def get_schemas(
+        self,
+        assistant_id: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> GraphSchema:
+        """Get the schemas of an assistant by ID.
+
+        Args:
+            assistant_id: The ID of the assistant to get the schema of.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            GraphSchema: The graph schema for the assistant.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            schema = client.assistants.get_schemas(
+                assistant_id="my_assistant_id"
+            )
+            print(schema)
+            ```
+            ```shell
+            ----------------------------------------------------------------------------------------------------------------------------
+
+            {
+                'graph_id': 'agent',
+                'state_schema':
+                    {
+                        'title': 'LangGraphInput',
+                        '$ref': '#/definitions/AgentState',
+                        'definitions':
+                            {
+                                'BaseMessage':
+                                    {
+                                        'title': 'BaseMessage',
+                                        'description': 'Base abstract Message class. Messages are the inputs and outputs of ChatModels.',
+                                        'type': 'object',
+                                        'properties':
+                                            {
+                                             'content':
+                                                {
+                                                    'title': 'Content',
+                                                    'anyOf': [
+                                                        {'type': 'string'},
+                                                        {'type': 'array','items': {'anyOf': [{'type': 'string'}, {'type': 'object'}]}}
+                                                    ]
+                                                },
+                                            'additional_kwargs':
+                                                {
+                                                    'title': 'Additional Kwargs',
+                                                    'type': 'object'
+                                                },
+                                            'response_metadata':
+                                                {
+                                                    'title': 'Response Metadata',
+                                                    'type': 'object'
+                                                },
+                                            'type':
+                                                {
+                                                    'title': 'Type',
+                                                    'type': 'string'
+                                                },
+                                            'name':
+                                                {
+                                                    'title': 'Name',
+                                                    'type': 'string'
+                                                },
+                                            'id':
+                                                {
+                                                    'title': 'Id',
+                                                    'type': 'string'
+                                                }
+                                            },
+                                        'required': ['content', 'type']
+                                    },
+                                'AgentState':
+                                    {
+                                        'title': 'AgentState',
+                                        'type': 'object',
+                                        'properties':
+                                            {
+                                                'messages':
+                                                    {
+                                                        'title': 'Messages',
+                                                        'type': 'array',
+                                                        'items': {'$ref': '#/definitions/BaseMessage'}
+                                                    }
+                                            },
+                                        'required': ['messages']
+                                    }
+                            }
+                    },
+                'config_schema':
+                    {
+                        'title': 'Configurable',
+                        'type': 'object',
+                        'properties':
+                            {
+                                'model_name':
+                                    {
+                                        'title': 'Model Name',
+                                        'enum': ['anthropic', 'openai'],
+                                        'type': 'string'
+                                    }
+                            }
+                    },
+                'context_schema':
+                    {
+                        'title': 'Context',
+                        'type': 'object',
+                        'properties':
+                            {
+                                'model_name':
+                                    {
+                                        'title': 'Model Name',
+                                        'enum': ['anthropic', 'openai'],
+                                        'type': 'string'
+                                    }
+                            }
+                    }
+            }
+            ```
+
+        """
+        return self.http.get(
+            f"/assistants/{assistant_id}/schemas", headers=headers, params=params
+        )
+
+    def get_subgraphs(
+        self,
+        assistant_id: str,
+        namespace: str | None = None,
+        recurse: bool = False,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Subgraphs:
+        """Get the schemas of an assistant by ID.
+
+        Args:
+            assistant_id: The ID of the assistant to get the schema of.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            Subgraphs: The graph schema for the assistant.
+
+        """
+        get_params = {"recurse": recurse}
+        if params:
+            get_params = {**get_params, **params}
+        if namespace is not None:
+            return self.http.get(
+                f"/assistants/{assistant_id}/subgraphs/{namespace}",
+                params=get_params,
+                headers=headers,
+            )
+        else:
+            return self.http.get(
+                f"/assistants/{assistant_id}/subgraphs",
+                params=get_params,
+                headers=headers,
+            )
+
+    def create(
+        self,
+        graph_id: str | None,
+        config: Config | None = None,
+        *,
+        context: Context | None = None,
+        metadata: Json = None,
+        assistant_id: str | None = None,
+        if_exists: OnConflictBehavior | None = None,
+        name: str | None = None,
+        headers: Mapping[str, str] | None = None,
+        description: str | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Assistant:
+        """Create a new assistant.
+
+        Useful when graph is configurable and you want to create different assistants based on different configurations.
+
+        Args:
+            graph_id: The ID of the graph the assistant should use. The graph ID is normally set in your langgraph.json configuration.
+            config: Configuration to use for the graph.
+            context: Static context to add to the assistant.
+                !!! version-added "Added in version 0.6.0"
+            metadata: Metadata to add to assistant.
+            assistant_id: Assistant ID to use, will default to a random UUID if not provided.
+            if_exists: How to handle duplicate creation. Defaults to 'raise' under the hood.
+                Must be either 'raise' (raise error if duplicate), or 'do_nothing' (return existing assistant).
+            name: The name of the assistant. Defaults to 'Untitled' under the hood.
+            headers: Optional custom headers to include with the request.
+            description: Optional description of the assistant.
+                The description field is available for langgraph-api server version>=0.0.45
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            The created assistant.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            assistant = client.assistants.create(
+                graph_id="agent",
+                context={"model_name": "openai"},
+                metadata={"number":1},
+                assistant_id="my-assistant-id",
+                if_exists="do_nothing",
+                name="my_name"
+            )
+            ```
+        """
+        payload: dict[str, Any] = {
+            "graph_id": graph_id,
+        }
+        if config:
+            payload["config"] = config
+        if context:
+            payload["context"] = context
+        if metadata:
+            payload["metadata"] = metadata
+        if assistant_id:
+            payload["assistant_id"] = assistant_id
+        if if_exists:
+            payload["if_exists"] = if_exists
+        if name:
+            payload["name"] = name
+        if description:
+            payload["description"] = description
+        return self.http.post(
+            "/assistants", json=payload, headers=headers, params=params
+        )
+
+    def update(
+        self,
+        assistant_id: str,
+        *,
+        graph_id: str | None = None,
+        config: Config | None = None,
+        context: Context | None = None,
+        metadata: Json = None,
+        name: str | None = None,
+        headers: Mapping[str, str] | None = None,
+        description: str | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Assistant:
+        """Update an assistant.
+
+        Use this to point to a different graph, update the configuration, or change the metadata of an assistant.
+
+        Args:
+            assistant_id: Assistant to update.
+            graph_id: The ID of the graph the assistant should use.
+                The graph ID is normally set in your langgraph.json configuration. If `None`, assistant will keep pointing to same graph.
+            config: Configuration to use for the graph.
+            context: Static context to add to the assistant.
+                !!! version-added "Added in version 0.6.0"
+            metadata: Metadata to merge with existing assistant metadata.
+            name: The new name for the assistant.
+            headers: Optional custom headers to include with the request.
+            description: Optional description of the assistant.
+                The description field is available for langgraph-api server version>=0.0.45
+
+        Returns:
+            The updated assistant.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            assistant = client.assistants.update(
+                assistant_id='e280dad7-8618-443f-87f1-8e41841c180f',
+                graph_id="other-graph",
+                context={"model_name": "anthropic"},
+                metadata={"number":2}
+            )
+            ```
+        """
+        payload: dict[str, Any] = {}
+        if graph_id:
+            payload["graph_id"] = graph_id
+        if config:
+            payload["config"] = config
+        if context:
+            payload["context"] = context
+        if metadata:
+            payload["metadata"] = metadata
+        if name:
+            payload["name"] = name
+        if description:
+            payload["description"] = description
+        return self.http.patch(
+            f"/assistants/{assistant_id}",
+            json=payload,
+            headers=headers,
+            params=params,
+        )
+
+    def delete(
+        self,
+        assistant_id: str,
+        *,
+        delete_threads: bool = False,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None:
+        """Delete an assistant.
+
+        Args:
+            assistant_id: The assistant ID to delete.
+            delete_threads: If true, delete all threads with `metadata.assistant_id`
+                matching this assistant, along with runs and checkpoints belonging to
+                those threads.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            client.assistants.delete(
+                assistant_id="my_assistant_id"
+            )
+            ```
+
+        """
+        query_params: dict[str, Any] = {}
+        if delete_threads:
+            query_params["delete_threads"] = True
+        if params:
+            query_params.update(params)
+        self.http.delete(
+            f"/assistants/{assistant_id}",
+            headers=headers,
+            params=query_params or None,
+        )
+
+    @overload
+    def search(
+        self,
+        *,
+        metadata: Json = None,
+        graph_id: str | None = None,
+        name: str | None = None,
+        limit: int = 10,
+        offset: int = 0,
+        sort_by: AssistantSortBy | None = None,
+        sort_order: SortOrder | None = None,
+        select: list[AssistantSelectField] | None = None,
+        response_format: Literal["object"],
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> AssistantsSearchResponse: ...
+
+    @overload
+    def search(
+        self,
+        *,
+        metadata: Json = None,
+        graph_id: str | None = None,
+        name: str | None = None,
+        limit: int = 10,
+        offset: int = 0,
+        sort_by: AssistantSortBy | None = None,
+        sort_order: SortOrder | None = None,
+        select: list[AssistantSelectField] | None = None,
+        response_format: Literal["array"] = "array",
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> list[Assistant]: ...
+
+    def search(
+        self,
+        *,
+        metadata: Json = None,
+        graph_id: str | None = None,
+        name: str | None = None,
+        limit: int = 10,
+        offset: int = 0,
+        sort_by: AssistantSortBy | None = None,
+        sort_order: SortOrder | None = None,
+        select: list[AssistantSelectField] | None = None,
+        response_format: Literal["array", "object"] = "array",
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> AssistantsSearchResponse | list[Assistant]:
+        """Search for assistants.
+
+        Args:
+            metadata: Metadata to filter by. Exact match filter for each KV pair.
+            graph_id: The ID of the graph to filter by.
+                The graph ID is normally set in your langgraph.json configuration.
+            name: The name of the assistant to filter by.
+                The filtering logic will match assistants where 'name' is a substring (case insensitive) of the assistant name.
+            limit: The maximum number of results to return.
+            offset: The number of results to skip.
+            sort_by: The field to sort by.
+            sort_order: The order to sort by.
+            select: Specific assistant fields to include in the response.
+            response_format: Controls the response shape. Use `"array"` (default)
+                to return a bare list of assistants, or `"object"` to return
+                a mapping containing assistants plus pagination metadata.
+                Defaults to "array", though this default will be changed to "object" in a future release.
+            headers: Optional custom headers to include with the request.
+
+        Returns:
+            A list of assistants (when `response_format="array"`) or a mapping
+            with the assistants and the next pagination cursor (when
+            `response_format="object"`).
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            response = client.assistants.search(
+                metadata = {"name":"my_name"},
+                graph_id="my_graph_id",
+                limit=5,
+                offset=5,
+                response_format="object",
+            )
+            assistants = response["assistants"]
+            next_cursor = response["next"]
+            ```
+        """
+        if response_format not in ("array", "object"):
+            raise ValueError("response_format must be 'array' or 'object'")
+        payload: dict[str, Any] = {
+            "limit": limit,
+            "offset": offset,
+        }
+        if metadata:
+            payload["metadata"] = metadata
+        if graph_id:
+            payload["graph_id"] = graph_id
+        if name:
+            payload["name"] = name
+        if sort_by:
+            payload["sort_by"] = sort_by
+        if sort_order:
+            payload["sort_order"] = sort_order
+        if select:
+            payload["select"] = select
+        next_cursor: str | None = None
+
+        def capture_pagination(response: httpx.Response) -> None:
+            nonlocal next_cursor
+            next_cursor = response.headers.get("X-Pagination-Next")
+
+        assistants = cast(
+            list[Assistant],
+            self.http.post(
+                "/assistants/search",
+                json=payload,
+                headers=headers,
+                params=params,
+                on_response=capture_pagination if response_format == "object" else None,
+            ),
+        )
+        if response_format == "object":
+            return {"assistants": assistants, "next": next_cursor}
+        return assistants
+
+    def count(
+        self,
+        *,
+        metadata: Json = None,
+        graph_id: str | None = None,
+        name: str | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> int:
+        """Count assistants matching filters.
+
+        Args:
+            metadata: Metadata to filter by. Exact match for each key/value.
+            graph_id: Optional graph id to filter by.
+            name: Optional name to filter by.
+                The filtering logic will match assistants where 'name' is a substring (case insensitive) of the assistant name.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            int: Number of assistants matching the criteria.
+        """
+        payload: dict[str, Any] = {}
+        if metadata:
+            payload["metadata"] = metadata
+        if graph_id:
+            payload["graph_id"] = graph_id
+        if name:
+            payload["name"] = name
+        return self.http.post(
+            "/assistants/count", json=payload, headers=headers, params=params
+        )
+
+    def get_versions(
+        self,
+        assistant_id: str,
+        metadata: Json = None,
+        limit: int = 10,
+        offset: int = 0,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> list[AssistantVersion]:
+        """List all versions of an assistant.
+
+        Args:
+            assistant_id: The assistant ID to get versions for.
+            metadata: Metadata to filter versions by. Exact match filter for each KV pair.
+            limit: The maximum number of versions to return.
+            offset: The number of versions to skip.
+            headers: Optional custom headers to include with the request.
+
+        Returns:
+            A list of assistants.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            assistant_versions = client.assistants.get_versions(
+                assistant_id="my_assistant_id"
+            )
+            ```
+
+        """
+
+        payload: dict[str, Any] = {
+            "limit": limit,
+            "offset": offset,
+        }
+        if metadata:
+            payload["metadata"] = metadata
+        return self.http.post(
+            f"/assistants/{assistant_id}/versions",
+            json=payload,
+            headers=headers,
+            params=params,
+        )
+
+    def set_latest(
+        self,
+        assistant_id: str,
+        version: int,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Assistant:
+        """Change the version of an assistant.
+
+        Args:
+            assistant_id: The assistant ID to delete.
+            version: The version to change to.
+            headers: Optional custom headers to include with the request.
+
+        Returns:
+            `Assistant` Object.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            new_version_assistant = client.assistants.set_latest(
+                assistant_id="my_assistant_id",
+                version=3
+            )
+            ```
+
+        """
+
+        payload: dict[str, Any] = {"version": version}
+
+        return self.http.post(
+            f"/assistants/{assistant_id}/latest",
+            json=payload,
+            headers=headers,
+            params=params,
+        )

libs/sdk-py/langgraph_sdk/_sync/client.py

@@ -0,0 +1,127 @@
+"""Sync LangGraph client."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from types import TracebackType
+
+import httpx
+
+from langgraph_sdk._shared.types import TimeoutTypes
+from langgraph_sdk._shared.utilities import NOT_PROVIDED, _get_headers
+from langgraph_sdk._sync.assistants import SyncAssistantsClient
+from langgraph_sdk._sync.cron import SyncCronClient
+from langgraph_sdk._sync.http import SyncHttpClient
+from langgraph_sdk._sync.runs import SyncRunsClient
+from langgraph_sdk._sync.store import SyncStoreClient
+from langgraph_sdk._sync.threads import SyncThreadsClient
+
+
+def get_sync_client(
+    *,
+    url: str | None = None,
+    api_key: str | None = NOT_PROVIDED,
+    headers: Mapping[str, str] | None = None,
+    timeout: TimeoutTypes | None = None,
+) -> SyncLangGraphClient:
+    """Get a synchronous LangGraphClient instance.
+
+    Args:
+        url: The URL of the LangGraph API.
+        api_key: API key for authentication. Can be:
+            - A string: use this exact API key
+            - `None`: explicitly skip loading from environment variables
+            - Not provided (default): auto-load from environment in this order:
+                1. `LANGGRAPH_API_KEY`
+                2. `LANGSMITH_API_KEY`
+                3. `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:
+        SyncLangGraphClient: The top-level synchronous client for accessing AssistantsClient,
+        ThreadsClient, RunsClient, and CronClient.
+
+    ???+ example "Example"
+
+        ```python
+        from langgraph_sdk import get_sync_client
+
+        # get top-level synchronous LangGraphClient
+        client = get_sync_client(url="http://localhost:8123")
+
+        # example usage: client.<model>.<method_name>()
+        assistant = client.assistants.get(assistant_id="some_uuid")
+        ```
+
+    ???+ example "Skip auto-loading API key from environment:"
+
+        ```python
+        from langgraph_sdk import get_sync_client
+
+        # Don't load API key from environment variables
+        client = get_sync_client(
+            url="http://localhost:8123",
+            api_key=None
+        )
+        ```
+    """
+
+    if url is None:
+        url = "http://localhost:8123"
+
+    transport = httpx.HTTPTransport(retries=5)
+    client = httpx.Client(
+        base_url=url,
+        transport=transport,
+        timeout=(
+            httpx.Timeout(timeout)  # type: ignore[arg-type]
+            if timeout is not None
+            else httpx.Timeout(connect=5, read=300, write=300, pool=5)
+        ),
+        headers=_get_headers(api_key, headers),
+    )
+    return SyncLangGraphClient(client)
+
+
+class SyncLangGraphClient:
+    """Synchronous client for interacting with the LangGraph API.
+
+    This class provides synchronous access to LangGraph API endpoints for managing
+    assistants, threads, runs, cron jobs, and data storage.
+
+    ???+ example "Example"
+
+        ```python
+        client = get_sync_client(url="http://localhost:2024")
+        assistant = client.assistants.get("asst_123")
+        ```
+    """
+
+    def __init__(self, client: httpx.Client) -> None:
+        self.http = SyncHttpClient(client)
+        self.assistants = SyncAssistantsClient(self.http)
+        self.threads = SyncThreadsClient(self.http)
+        self.runs = SyncRunsClient(self.http)
+        self.crons = SyncCronClient(self.http)
+        self.store = SyncStoreClient(self.http)
+
+    def __enter__(self) -> SyncLangGraphClient:
+        """Enter the sync context manager."""
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Exit the sync context manager."""
+        self.close()
+
+    def close(self) -> None:
+        """Close the underlying HTTP client."""
+        if hasattr(self, "http"):
+            self.http.client.close()

libs/sdk-py/langgraph_sdk/_sync/cron.py

@@ -0,0 +1,439 @@
+"""Synchronous cron client for LangGraph SDK."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from datetime import datetime
+from typing import Any
+
+from langgraph_sdk._sync.http import SyncHttpClient
+from langgraph_sdk.schema import (
+    All,
+    Config,
+    Context,
+    Cron,
+    CronSelectField,
+    CronSortBy,
+    Input,
+    OnCompletionBehavior,
+    QueryParamTypes,
+    Run,
+    SortOrder,
+)
+
+
+class SyncCronClient:
+    """Synchronous client for managing cron jobs in LangGraph.
+
+    This class provides methods to create and manage scheduled tasks (cron jobs) for automated graph executions.
+
+    ???+ example "Example"
+
+        ```python
+        client = get_sync_client(url="http://localhost:8123")
+        cron_job = client.crons.create_for_thread(thread_id="thread_123", assistant_id="asst_456", schedule="0 * * * *")
+        ```
+
+    !!! note "Feature Availability"
+
+        The crons client functionality is not supported on all licenses.
+        Please check the relevant license documentation for the most up-to-date
+        details on feature availability.
+    """
+
+    def __init__(self, http_client: SyncHttpClient) -> None:
+        self.http = http_client
+
+    def create_for_thread(
+        self,
+        thread_id: str,
+        assistant_id: str,
+        *,
+        schedule: str,
+        input: Input | None = None,
+        metadata: Mapping[str, Any] | None = None,
+        config: Config | None = None,
+        context: Context | None = None,
+        checkpoint_during: bool | None = None,
+        interrupt_before: All | list[str] | None = None,
+        interrupt_after: All | list[str] | None = None,
+        webhook: str | None = None,
+        multitask_strategy: str | None = None,
+        end_time: datetime | None = None,
+        enabled: bool | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Run:
+        """Create a cron job for a thread.
+
+        Args:
+            thread_id: the thread ID to run the cron job on.
+            assistant_id: The assistant ID or graph name to use for the cron job.
+                If using graph name, will default to first assistant created from that graph.
+            schedule: The cron schedule to execute this job on.
+                Schedules are interpreted in UTC.
+            input: The input to the graph.
+            metadata: Metadata to assign to the cron job runs.
+            config: The configuration for the assistant.
+            context: Static context to add to the assistant.
+                !!! version-added "Added in version 0.6.0"
+            checkpoint_during: Whether to checkpoint during the run (or only at the end/interruption).
+            interrupt_before: Nodes to interrupt immediately before they get executed.
+            interrupt_after: Nodes to Nodes to interrupt immediately after they get executed.
+            webhook: Webhook to call after LangGraph API call is done.
+            multitask_strategy: Multitask strategy to use.
+                Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'.
+            end_time: The time to stop running the cron job. If not provided, the cron job will run indefinitely.
+            enabled: Whether the cron job is enabled. By default, it is considered enabled.
+            headers: Optional custom headers to include with the request.
+
+        Returns:
+            The cron `Run`.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:8123")
+            cron_run = client.crons.create_for_thread(
+                thread_id="my-thread-id",
+                assistant_id="agent",
+                schedule="27 15 * * *",
+                input={"messages": [{"role": "user", "content": "hello!"}]},
+                metadata={"name":"my_run"},
+                context={"model_name": "openai"},
+                interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"],
+                interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"],
+                webhook="https://my.fake.webhook.com",
+                multitask_strategy="interrupt",
+                enabled=True
+            )
+            ```
+        """
+        payload = {
+            "schedule": schedule,
+            "input": input,
+            "config": config,
+            "metadata": metadata,
+            "context": context,
+            "assistant_id": assistant_id,
+            "interrupt_before": interrupt_before,
+            "interrupt_after": interrupt_after,
+            "checkpoint_during": checkpoint_during,
+            "webhook": webhook,
+            "multitask_strategy": multitask_strategy,
+            "end_time": end_time.isoformat() if end_time else None,
+            "enabled": enabled,
+        }
+        payload = {k: v for k, v in payload.items() if v is not None}
+        return self.http.post(
+            f"/threads/{thread_id}/runs/crons",
+            json=payload,
+            headers=headers,
+            params=params,
+        )
+
+    def create(
+        self,
+        assistant_id: str,
+        *,
+        schedule: str,
+        input: Input | None = None,
+        metadata: Mapping[str, Any] | None = None,
+        config: Config | None = None,
+        context: Context | None = None,
+        checkpoint_during: bool | None = None,
+        interrupt_before: All | list[str] | None = None,
+        interrupt_after: All | list[str] | None = None,
+        webhook: str | None = None,
+        on_run_completed: OnCompletionBehavior | None = None,
+        multitask_strategy: str | None = None,
+        end_time: datetime | None = None,
+        enabled: bool | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Run:
+        """Create a cron run.
+
+        Args:
+            assistant_id: The assistant ID or graph name to use for the cron job.
+                If using graph name, will default to first assistant created from that graph.
+            schedule: The cron schedule to execute this job on.
+                Schedules are interpreted in UTC.
+            input: The input to the graph.
+            metadata: Metadata to assign to the cron job runs.
+            config: The configuration for the assistant.
+            context: Static context to add to the assistant.
+                !!! version-added "Added in version 0.6.0"
+            checkpoint_during: Whether to checkpoint during the run (or only at the end/interruption).
+            interrupt_before: Nodes to interrupt immediately before they get executed.
+            interrupt_after: Nodes to Nodes to interrupt immediately after they get executed.
+            webhook: Webhook to call after LangGraph API call is done.
+            on_run_completed: What to do with the thread after the run completes.
+                Must be one of 'delete' (default) or 'keep'. 'delete' removes the thread
+                after execution. 'keep' creates a new thread for each execution but does not
+                clean them up. Clients are responsible for cleaning up kept threads.
+            multitask_strategy: Multitask strategy to use.
+                Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'.
+            end_time: The time to stop running the cron job. If not provided, the cron job will run indefinitely.
+            enabled: Whether the cron job is enabled. By default, it is considered enabled.
+            headers: Optional custom headers to include with the request.
+
+        Returns:
+            The cron `Run`.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:8123")
+            cron_run = client.crons.create(
+                assistant_id="agent",
+                schedule="27 15 * * *",
+                input={"messages": [{"role": "user", "content": "hello!"}]},
+                metadata={"name":"my_run"},
+                context={"model_name": "openai"},
+                checkpoint_during=True,
+                interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"],
+                interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"],
+                webhook="https://my.fake.webhook.com",
+                multitask_strategy="interrupt",
+                enabled=True
+            )
+            ```
+
+        """
+        payload = {
+            "schedule": schedule,
+            "input": input,
+            "config": config,
+            "metadata": metadata,
+            "context": context,
+            "assistant_id": assistant_id,
+            "interrupt_before": interrupt_before,
+            "interrupt_after": interrupt_after,
+            "webhook": webhook,
+            "checkpoint_during": checkpoint_during,
+            "on_run_completed": on_run_completed,
+            "multitask_strategy": multitask_strategy,
+            "end_time": end_time.isoformat() if end_time else None,
+            "enabled": enabled,
+        }
+        payload = {k: v for k, v in payload.items() if v is not None}
+        return self.http.post(
+            "/runs/crons", json=payload, headers=headers, params=params
+        )
+
+    def delete(
+        self,
+        cron_id: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None:
+        """Delete a cron.
+
+        Args:
+            cron_id: The cron ID to delete.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:8123")
+            client.crons.delete(
+                cron_id="cron_to_delete"
+            )
+            ```
+
+        """
+        self.http.delete(f"/runs/crons/{cron_id}", headers=headers, params=params)
+
+    def update(
+        self,
+        cron_id: str,
+        *,
+        schedule: str | None = None,
+        end_time: datetime | None = None,
+        input: Input | None = None,
+        metadata: Mapping[str, Any] | None = None,
+        config: Config | None = None,
+        context: Context | None = None,
+        webhook: str | None = None,
+        interrupt_before: All | list[str] | None = None,
+        interrupt_after: All | list[str] | None = None,
+        on_run_completed: OnCompletionBehavior | None = None,
+        enabled: bool | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Cron:
+        """Update a cron job by ID.
+
+        Args:
+            cron_id: The cron ID to update.
+            schedule: The cron schedule to execute this job on.
+                Schedules are interpreted in UTC.
+            end_time: The end date to stop running the cron.
+            input: The input to the graph.
+            metadata: Metadata to assign to the cron job runs.
+            config: The configuration for the assistant.
+            context: Static context added to the assistant.
+            webhook: Webhook to call after LangGraph API call is done.
+            interrupt_before: Nodes to interrupt immediately before they get executed.
+            interrupt_after: Nodes to interrupt immediately after they get executed.
+            on_run_completed: What to do with the thread after the run completes.
+                Must be one of 'delete' or 'keep'. 'delete' removes the thread
+                after execution. 'keep' creates a new thread for each execution but does not
+                clean them up.
+            enabled: Enable or disable the cron job.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            The updated cron job.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:8123")
+            updated_cron = client.crons.update(
+                cron_id="1ef3cefa-4c09-6926-96d0-3dc97fd5e39b",
+                schedule="0 10 * * *",
+                enabled=False,
+            )
+            ```
+
+        """
+        payload = {
+            "schedule": schedule,
+            "end_time": end_time.isoformat() if end_time else None,
+            "input": input,
+            "metadata": metadata,
+            "config": config,
+            "context": context,
+            "webhook": webhook,
+            "interrupt_before": interrupt_before,
+            "interrupt_after": interrupt_after,
+            "on_run_completed": on_run_completed,
+            "enabled": enabled,
+        }
+        payload = {k: v for k, v in payload.items() if v is not None}
+        return self.http.patch(
+            f"/runs/crons/{cron_id}",
+            json=payload,
+            headers=headers,
+            params=params,
+        )
+
+    def search(
+        self,
+        *,
+        assistant_id: str | None = None,
+        thread_id: str | None = None,
+        enabled: bool | None = None,
+        limit: int = 10,
+        offset: int = 0,
+        sort_by: CronSortBy | None = None,
+        sort_order: SortOrder | None = None,
+        select: list[CronSelectField] | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> list[Cron]:
+        """Get a list of cron jobs.
+
+        Args:
+            assistant_id: The assistant ID or graph name to search for.
+            thread_id: the thread ID to search for.
+            enabled: Whether the cron job is enabled.
+            limit: The maximum number of results to return.
+            offset: The number of results to skip.
+            headers: Optional custom headers to include with the request.
+
+        Returns:
+            The list of cron jobs returned by the search,
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:8123")
+            cron_jobs = client.crons.search(
+                assistant_id="my_assistant_id",
+                thread_id="my_thread_id",
+                enabled=True,
+                limit=5,
+                offset=5,
+            )
+            print(cron_jobs)
+            ```
+
+            ```shell
+            ----------------------------------------------------------
+
+            [
+                {
+                    'cron_id': '1ef3cefa-4c09-6926-96d0-3dc97fd5e39b',
+                    'assistant_id': 'my_assistant_id',
+                    'thread_id': 'my_thread_id',
+                    'user_id': None,
+                    'payload':
+                        {
+                            'input': {'start_time': ''},
+                            'schedule': '4 * * * *',
+                            'assistant_id': 'my_assistant_id'
+                        },
+                    'schedule': '4 * * * *',
+                    'next_run_date': '2024-07-25T17:04:00+00:00',
+                    'end_time': None,
+                    'created_at': '2024-07-08T06:02:23.073257+00:00',
+                    'updated_at': '2024-07-08T06:02:23.073257+00:00'
+                }
+            ]
+            ```
+        """
+        payload = {
+            "assistant_id": assistant_id,
+            "thread_id": thread_id,
+            "enabled": enabled,
+            "limit": limit,
+            "offset": offset,
+        }
+        if sort_by:
+            payload["sort_by"] = sort_by
+        if sort_order:
+            payload["sort_order"] = sort_order
+        if select:
+            payload["select"] = select
+        payload = {k: v for k, v in payload.items() if v is not None}
+        return self.http.post(
+            "/runs/crons/search", json=payload, headers=headers, params=params
+        )
+
+    def count(
+        self,
+        *,
+        assistant_id: str | None = None,
+        thread_id: str | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> int:
+        """Count cron jobs matching filters.
+
+        Args:
+            assistant_id: Assistant ID to filter by.
+            thread_id: Thread ID to filter by.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            int: Number of crons matching the criteria.
+        """
+        payload: dict[str, Any] = {}
+        if assistant_id:
+            payload["assistant_id"] = assistant_id
+        if thread_id:
+            payload["thread_id"] = thread_id
+        return self.http.post(
+            "/runs/crons/count", json=payload, headers=headers, params=params
+        )

libs/sdk-py/langgraph_sdk/_sync/http.py

@@ -0,0 +1,296 @@
+"""Synchronous HTTP client for LangGraph API."""
+
+from __future__ import annotations
+
+import logging
+import sys
+import warnings
+from collections.abc import Callable, Iterator, Mapping
+from typing import Any, cast
+
+import httpx
+import orjson
+
+from langgraph_sdk._shared.utilities import _orjson_default
+from langgraph_sdk.errors import _raise_for_status_typed
+from langgraph_sdk.schema import QueryParamTypes, StreamPart
+from langgraph_sdk.sse import SSEDecoder, iter_lines_raw
+
+logger = logging.getLogger(__name__)
+
+
+class SyncHttpClient:
+    """Handle synchronous requests to the LangGraph API.
+
+    Provides error messaging and content handling enhancements above the
+    underlying httpx client, mirroring the interface of [HttpClient](#HttpClient)
+    but for sync usage.
+
+    Attributes:
+        client (httpx.Client): Underlying HTTPX sync client.
+    """
+
+    def __init__(self, client: httpx.Client) -> None:
+        self.client = client
+
+    def get(
+        self,
+        path: str,
+        *,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+    ) -> Any:
+        """Send a `GET` request."""
+        r = self.client.get(path, params=params, headers=headers)
+        if on_response:
+            on_response(r)
+        _raise_for_status_typed(r)
+        return _decode_json(r)
+
+    def post(
+        self,
+        path: str,
+        *,
+        json: dict[str, Any] | list | None,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+    ) -> Any:
+        """Send a `POST` request."""
+        if json is not None:
+            request_headers, content = _encode_json(json)
+        else:
+            request_headers, content = {}, b""
+        if headers:
+            request_headers.update(headers)
+        r = self.client.post(
+            path, headers=request_headers, content=content, params=params
+        )
+        if on_response:
+            on_response(r)
+        _raise_for_status_typed(r)
+        return _decode_json(r)
+
+    def put(
+        self,
+        path: str,
+        *,
+        json: dict,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+    ) -> Any:
+        """Send a `PUT` request."""
+        request_headers, content = _encode_json(json)
+        if headers:
+            request_headers.update(headers)
+
+        r = self.client.put(
+            path, headers=request_headers, content=content, params=params
+        )
+        if on_response:
+            on_response(r)
+        _raise_for_status_typed(r)
+        return _decode_json(r)
+
+    def patch(
+        self,
+        path: str,
+        *,
+        json: dict,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+    ) -> Any:
+        """Send a `PATCH` request."""
+        request_headers, content = _encode_json(json)
+        if headers:
+            request_headers.update(headers)
+        r = self.client.patch(
+            path, headers=request_headers, content=content, params=params
+        )
+        if on_response:
+            on_response(r)
+        _raise_for_status_typed(r)
+        return _decode_json(r)
+
+    def delete(
+        self,
+        path: str,
+        *,
+        json: Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+    ) -> None:
+        """Send a `DELETE` request."""
+        r = self.client.request(
+            "DELETE", path, json=json, params=params, headers=headers
+        )
+        if on_response:
+            on_response(r)
+        _raise_for_status_typed(r)
+
+    def request_reconnect(
+        self,
+        path: str,
+        method: str,
+        *,
+        json: dict[str, Any] | None = None,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+        reconnect_limit: int = 5,
+    ) -> Any:
+        """Send a request that automatically reconnects to Location header."""
+        request_headers, content = _encode_json(json)
+        if headers:
+            request_headers.update(headers)
+        with self.client.stream(
+            method, path, headers=request_headers, content=content, params=params
+        ) as r:
+            if on_response:
+                on_response(r)
+            try:
+                r.raise_for_status()
+            except httpx.HTTPStatusError as e:
+                body = r.read().decode()
+                if sys.version_info >= (3, 11):
+                    e.add_note(body)
+                else:
+                    logger.error(f"Error from langgraph-api: {body}", exc_info=e)
+                raise e
+            loc = r.headers.get("location")
+            if reconnect_limit <= 0 or not loc:
+                return _decode_json(r)
+            try:
+                return _decode_json(r)
+            except httpx.HTTPError:
+                warnings.warn(
+                    f"Request failed, attempting reconnect to Location: {loc}",
+                    stacklevel=2,
+                )
+                r.close()
+                return self.request_reconnect(
+                    loc,
+                    "GET",
+                    headers=request_headers,
+                    # don't pass on_response so it's only called once
+                    reconnect_limit=reconnect_limit - 1,
+                )
+
+    def stream(
+        self,
+        path: str,
+        method: str,
+        *,
+        json: dict[str, Any] | None = None,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+    ) -> Iterator[StreamPart]:
+        """Stream the results of a request using SSE."""
+        if json is not None:
+            request_headers, content = _encode_json(json)
+        else:
+            request_headers, content = {}, None
+        request_headers["Accept"] = "text/event-stream"
+        request_headers["Cache-Control"] = "no-store"
+        if headers:
+            request_headers.update(headers)
+
+        reconnect_headers = {
+            key: value
+            for key, value in request_headers.items()
+            if key.lower() not in {"content-length", "content-type"}
+        }
+
+        last_event_id: str | None = None
+        reconnect_path: str | None = None
+        reconnect_attempts = 0
+        max_reconnect_attempts = 5
+
+        while True:
+            current_headers = dict(
+                request_headers if reconnect_path is None else reconnect_headers
+            )
+            if last_event_id is not None:
+                current_headers["Last-Event-ID"] = last_event_id
+
+            current_method = method if reconnect_path is None else "GET"
+            current_content = content if reconnect_path is None else None
+            current_params = params if reconnect_path is None else None
+
+            retry = False
+            with self.client.stream(
+                current_method,
+                reconnect_path or path,
+                headers=current_headers,
+                content=current_content,
+                params=current_params,
+            ) as res:
+                if reconnect_path is None and on_response:
+                    on_response(res)
+                # check status
+                _raise_for_status_typed(res)
+                # check content type
+                content_type = res.headers.get("content-type", "").partition(";")[0]
+                if "text/event-stream" not in content_type:
+                    raise httpx.TransportError(
+                        "Expected response header Content-Type to contain 'text/event-stream', "
+                        f"got {content_type!r}"
+                    )
+
+                reconnect_location = res.headers.get("location")
+                if reconnect_location:
+                    reconnect_path = reconnect_location
+
+                decoder = SSEDecoder()
+                try:
+                    for line in iter_lines_raw(res):
+                        sse = decoder.decode(cast(bytes, line).rstrip(b"\n"))
+                        if sse is not None:
+                            if decoder.last_event_id is not None:
+                                last_event_id = decoder.last_event_id
+                            if sse.event or sse.data is not None:
+                                yield sse
+                except httpx.HTTPError:
+                    # httpx.TransportError inherits from HTTPError, so transient
+                    # disconnects during streaming land here.
+                    if reconnect_path is None:
+                        raise
+                    retry = True
+                else:
+                    if sse := decoder.decode(b""):
+                        if decoder.last_event_id is not None:
+                            last_event_id = decoder.last_event_id
+                        if sse.event or sse.data is not None:
+                            # See async stream implementation for rationale on
+                            # skipping empty flush events.
+                            yield sse
+            if retry:
+                reconnect_attempts += 1
+                if reconnect_attempts > max_reconnect_attempts:
+                    raise httpx.TransportError(
+                        "Exceeded maximum SSE reconnection attempts"
+                    )
+                continue
+            break
+
+
+def _encode_json(json: Any) -> tuple[dict[str, str], bytes]:
+    body = orjson.dumps(
+        json,
+        _orjson_default,
+        orjson.OPT_SERIALIZE_NUMPY | orjson.OPT_NON_STR_KEYS,
+    )
+    content_length = str(len(body))
+    content_type = "application/json"
+    headers = {"Content-Length": content_length, "Content-Type": content_type}
+    return headers, body
+
+
+def _decode_json(r: httpx.Response) -> Any:
+    body = r.read()
+    return orjson.loads(body) if body else None

libs/sdk-py/langgraph_sdk/_sync/store.py

@@ -0,0 +1,313 @@
+"""Synchronous store client for LangGraph SDK."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import Any, Literal
+
+from langgraph_sdk._shared.utilities import _provided_vals
+from langgraph_sdk._sync.http import SyncHttpClient
+from langgraph_sdk.schema import (
+    Item,
+    ListNamespaceResponse,
+    QueryParamTypes,
+    SearchItemsResponse,
+)
+
+
+class SyncStoreClient:
+    """A client for synchronous operations on a key-value store.
+
+    Provides methods to interact with a remote key-value store, allowing
+    storage and retrieval of items within namespaced hierarchies.
+
+    ???+ example "Example"
+
+        ```python
+        client = get_sync_client(url="http://localhost:2024"))
+        client.store.put_item(["users", "profiles"], "user123", {"name": "Alice", "age": 30})
+        ```
+    """
+
+    def __init__(self, http: SyncHttpClient) -> None:
+        self.http = http
+
+    def put_item(
+        self,
+        namespace: Sequence[str],
+        /,
+        key: str,
+        value: Mapping[str, Any],
+        index: Literal[False] | list[str] | None = None,
+        ttl: int | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None:
+        """Store or update an item.
+
+        Args:
+            namespace: A list of strings representing the namespace path.
+            key: The unique identifier for the item within the namespace.
+            value: A dictionary containing the item's data.
+            index: Controls search indexing - None (use defaults), False (disable), or list of field paths to index.
+            ttl: Optional time-to-live in minutes for the item, or None for no expiration.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:8123")
+            client.store.put_item(
+                ["documents", "user123"],
+                key="item456",
+                value={"title": "My Document", "content": "Hello World"}
+            )
+            ```
+        """
+        for label in namespace:
+            if "." in label:
+                raise ValueError(
+                    f"Invalid namespace label '{label}'. Namespace labels cannot contain periods ('.')."
+                )
+        payload = {
+            "namespace": namespace,
+            "key": key,
+            "value": value,
+            "index": index,
+            "ttl": ttl,
+        }
+        self.http.put(
+            "/store/items", json=_provided_vals(payload), headers=headers, params=params
+        )
+
+    def get_item(
+        self,
+        namespace: Sequence[str],
+        /,
+        key: str,
+        *,
+        refresh_ttl: bool | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Item:
+        """Retrieve a single item.
+
+        Args:
+            key: The unique identifier for the item.
+            namespace: Optional list of strings representing the namespace path.
+            refresh_ttl: Whether to refresh the TTL on this read operation. If `None`, uses the store's default behavior.
+            headers: Optional custom headers to include with the request.
+
+        Returns:
+            The retrieved item.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:8123")
+            item = client.store.get_item(
+                ["documents", "user123"],
+                key="item456",
+            )
+            print(item)
+            ```
+
+            ```shell
+            ----------------------------------------------------------------
+
+            {
+                'namespace': ['documents', 'user123'],
+                'key': 'item456',
+                'value': {'title': 'My Document', 'content': 'Hello World'},
+                'created_at': '2024-07-30T12:00:00Z',
+                'updated_at': '2024-07-30T12:00:00Z'
+            }
+            ```
+        """
+        for label in namespace:
+            if "." in label:
+                raise ValueError(
+                    f"Invalid namespace label '{label}'. Namespace labels cannot contain periods ('.')."
+                )
+
+        query_params = {"key": key, "namespace": ".".join(namespace)}
+        if refresh_ttl is not None:
+            query_params["refresh_ttl"] = refresh_ttl
+        if params:
+            query_params.update(params)
+        return self.http.get("/store/items", params=query_params, headers=headers)
+
+    def delete_item(
+        self,
+        namespace: Sequence[str],
+        /,
+        key: str,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None:
+        """Delete an item.
+
+        Args:
+            key: The unique identifier for the item.
+            namespace: Optional list of strings representing the namespace path.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:8123")
+            client.store.delete_item(
+                ["documents", "user123"],
+                key="item456",
+            )
+            ```
+        """
+        self.http.delete(
+            "/store/items",
+            json={"key": key, "namespace": namespace},
+            headers=headers,
+            params=params,
+        )
+
+    def search_items(
+        self,
+        namespace_prefix: Sequence[str],
+        /,
+        filter: Mapping[str, Any] | None = None,
+        limit: int = 10,
+        offset: int = 0,
+        query: str | None = None,
+        refresh_ttl: bool | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> SearchItemsResponse:
+        """Search for items within a namespace prefix.
+
+        Args:
+            namespace_prefix: List of strings representing the namespace prefix.
+            filter: Optional dictionary of key-value pairs to filter results.
+            limit: Maximum number of items to return (default is 10).
+            offset: Number of items to skip before returning results (default is 0).
+            query: Optional query for natural language search.
+            refresh_ttl: Whether to refresh the TTL on items returned by this search. If `None`, uses the store's default behavior.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            A list of items matching the search criteria.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:8123")
+            items = client.store.search_items(
+                ["documents"],
+                filter={"author": "John Doe"},
+                limit=5,
+                offset=0
+            )
+            print(items)
+            ```
+            ```shell
+            ----------------------------------------------------------------
+
+            {
+                "items": [
+                    {
+                        "namespace": ["documents", "user123"],
+                        "key": "item789",
+                        "value": {
+                            "title": "Another Document",
+                            "author": "John Doe"
+                        },
+                        "created_at": "2024-07-30T12:00:00Z",
+                        "updated_at": "2024-07-30T12:00:00Z"
+                    },
+                    # ... additional items ...
+                ]
+            }
+            ```
+        """
+        payload = {
+            "namespace_prefix": namespace_prefix,
+            "filter": filter,
+            "limit": limit,
+            "offset": offset,
+            "query": query,
+            "refresh_ttl": refresh_ttl,
+        }
+        return self.http.post(
+            "/store/items/search",
+            json=_provided_vals(payload),
+            headers=headers,
+            params=params,
+        )
+
+    def list_namespaces(
+        self,
+        prefix: list[str] | None = None,
+        suffix: list[str] | None = None,
+        max_depth: int | None = None,
+        limit: int = 100,
+        offset: int = 0,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> ListNamespaceResponse:
+        """List namespaces with optional match conditions.
+
+        Args:
+            prefix: Optional list of strings representing the prefix to filter namespaces.
+            suffix: Optional list of strings representing the suffix to filter namespaces.
+            max_depth: Optional integer specifying the maximum depth of namespaces to return.
+            limit: Maximum number of namespaces to return (default is 100).
+            offset: Number of namespaces to skip before returning results (default is 0).
+            headers: Optional custom headers to include with the request.
+
+        Returns:
+            A list of namespaces matching the criteria.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:8123")
+            namespaces = client.store.list_namespaces(
+                prefix=["documents"],
+                max_depth=3,
+                limit=10,
+                offset=0
+            )
+            print(namespaces)
+            ```
+
+            ```shell
+            ----------------------------------------------------------------
+
+            [
+                ["documents", "user123", "reports"],
+                ["documents", "user456", "invoices"],
+                ...
+            ]
+            ```
+        """
+        payload = {
+            "prefix": prefix,
+            "suffix": suffix,
+            "max_depth": max_depth,
+            "limit": limit,
+            "offset": offset,
+        }
+        return self.http.post(
+            "/store/namespaces",
+            json=_provided_vals(payload),
+            headers=headers,
+            params=params,
+        )

libs/sdk-py/langgraph_sdk/_sync/threads.py

@@ -0,0 +1,708 @@
+"""Synchronous client for managing threads in LangGraph."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator, Mapping, Sequence
+from typing import Any
+
+from langgraph_sdk._sync.http import SyncHttpClient
+from langgraph_sdk.schema import (
+    Checkpoint,
+    Json,
+    OnConflictBehavior,
+    PruneStrategy,
+    QueryParamTypes,
+    SortOrder,
+    StreamPart,
+    Thread,
+    ThreadSelectField,
+    ThreadSortBy,
+    ThreadState,
+    ThreadStatus,
+    ThreadStreamMode,
+    ThreadUpdateStateResponse,
+)
+
+
+class SyncThreadsClient:
+    """Synchronous client for managing threads in LangGraph.
+
+    This class provides methods to create, retrieve, and manage threads,
+    which represent conversations or stateful interactions.
+
+    ???+ example "Example"
+
+        ```python
+        client = get_sync_client(url="http://localhost:2024")
+        thread = client.threads.create(metadata={"user_id": "123"})
+        ```
+    """
+
+    def __init__(self, http: SyncHttpClient) -> None:
+        self.http = http
+
+    def get(
+        self,
+        thread_id: str,
+        *,
+        include: Sequence[str] | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Thread:
+        """Get a thread by ID.
+
+        Args:
+            thread_id: The ID of the thread to get.
+            include: Additional fields to include in the response.
+                Supported values: `"ttl"`.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `Thread` object.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            thread = client.threads.get(
+                thread_id="my_thread_id"
+            )
+            print(thread)
+            ```
+            ```shell
+            -----------------------------------------------------
+
+            {
+                'thread_id': 'my_thread_id',
+                'created_at': '2024-07-18T18:35:15.540834+00:00',
+                'updated_at': '2024-07-18T18:35:15.540834+00:00',
+                'metadata': {'graph_id': 'agent'}
+            }
+            ```
+
+        """
+        query_params: dict[str, Any] = {}
+        if include:
+            query_params["include"] = ",".join(include)
+        if params:
+            query_params.update(params)
+        return self.http.get(
+            f"/threads/{thread_id}",
+            headers=headers,
+            params=query_params or None,
+        )
+
+    def create(
+        self,
+        *,
+        metadata: Json = None,
+        thread_id: str | None = None,
+        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:
+        """Create a new thread.
+
+        Args:
+            metadata: Metadata to add to thread.
+            thread_id: ID of thread.
+                If `None`, ID will be a randomly generated UUID.
+            if_exists: How to handle duplicate creation. Defaults to 'raise' under the hood.
+                Must be either 'raise' (raise error if duplicate), or 'do_nothing' (return existing thread).
+            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:
+            The created `Thread`.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            thread = client.threads.create(
+                metadata={"number":1},
+                thread_id="my-thread-id",
+                if_exists="raise"
+            )
+            ```
+            )
+        """
+        payload: dict[str, Any] = {}
+        if thread_id:
+            payload["thread_id"] = thread_id
+        if metadata or graph_id:
+            payload["metadata"] = {
+                **(metadata or {}),
+                **({"graph_id": graph_id} if graph_id else {}),
+            }
+        if if_exists:
+            payload["if_exists"] = if_exists
+        if supersteps:
+            payload["supersteps"] = [
+                {
+                    "updates": [
+                        {
+                            "values": u["values"],
+                            "command": u.get("command"),
+                            "as_node": u["as_node"],
+                        }
+                        for u in s["updates"]
+                    ]
+                }
+                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)
+
+    def update(
+        self,
+        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:
+        """Update a thread.
+
+        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:
+            The created `Thread`.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            thread = client.threads.update(
+                thread_id="my-thread-id",
+                metadata={"number":1},
+                ttl=43_200,
+            )
+            ```
+        """
+        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,
+            headers=headers,
+            params=params,
+        )
+
+    def delete(
+        self,
+        thread_id: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None:
+        """Delete a thread.
+
+        Args:
+            thread_id: The ID of the thread to delete.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client.threads.delete(
+                thread_id="my_thread_id"
+            )
+            ```
+
+        """
+        self.http.delete(f"/threads/{thread_id}", headers=headers, params=params)
+
+    def search(
+        self,
+        *,
+        metadata: Json = None,
+        values: Json = None,
+        ids: Sequence[str] | None = None,
+        status: ThreadStatus | None = None,
+        limit: int = 10,
+        offset: int = 0,
+        sort_by: ThreadSortBy | None = None,
+        sort_order: SortOrder | None = None,
+        select: list[ThreadSelectField] | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> list[Thread]:
+        """Search for threads.
+
+        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.
+            offset: Offset in threads table to start search from.
+            headers: Optional custom headers to include with the request.
+
+        Returns:
+            List of the threads matching the search parameters.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            threads = client.threads.search(
+                metadata={"number":1},
+                status="interrupted",
+                limit=15,
+                offset=5
+            )
+            ```
+        """
+        payload: dict[str, Any] = {
+            "limit": limit,
+            "offset": offset,
+        }
+        if metadata:
+            payload["metadata"] = metadata
+        if values:
+            payload["values"] = values
+        if ids:
+            payload["ids"] = ids
+        if status:
+            payload["status"] = status
+        if sort_by:
+            payload["sort_by"] = sort_by
+        if sort_order:
+            payload["sort_order"] = sort_order
+        if select:
+            payload["select"] = select
+        return self.http.post(
+            "/threads/search", json=payload, headers=headers, params=params
+        )
+
+    def count(
+        self,
+        *,
+        metadata: Json = None,
+        values: Json = None,
+        status: ThreadStatus | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> int:
+        """Count threads matching filters.
+
+        Args:
+            metadata: Thread metadata to filter on.
+            values: State values to filter on.
+            status: Thread status to filter on.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            int: Number of threads matching the criteria.
+        """
+        payload: dict[str, Any] = {}
+        if metadata:
+            payload["metadata"] = metadata
+        if values:
+            payload["values"] = values
+        if status:
+            payload["status"] = status
+        return self.http.post(
+            "/threads/count", json=payload, headers=headers, params=params
+        )
+
+    def copy(
+        self,
+        thread_id: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None:
+        """Copy a thread.
+
+        Args:
+            thread_id: The ID of the thread to copy.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            client.threads.copy(
+                thread_id="my_thread_id"
+            )
+            ```
+
+        """
+        return self.http.post(
+            f"/threads/{thread_id}/copy", json=None, headers=headers, params=params
+        )
+
+    def prune(
+        self,
+        thread_ids: Sequence[str],
+        *,
+        strategy: PruneStrategy = "delete",
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> dict[str, Any]:
+        """Prune threads by ID.
+
+        Args:
+            thread_ids: List of thread IDs to prune.
+            strategy: The prune strategy. `"delete"` removes threads entirely.
+                `"keep_latest"` prunes old checkpoints but keeps threads and their
+                latest state. Defaults to `"delete"`.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            A dict containing `pruned_count` (number of threads pruned).
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            result = client.threads.prune(
+                thread_ids=["thread_1", "thread_2"],
+            )
+            print(result)  # {'pruned_count': 2}
+            ```
+
+        """
+        payload: dict[str, Any] = {
+            "thread_ids": thread_ids,
+        }
+        if strategy != "delete":
+            payload["strategy"] = strategy
+        return self.http.post(
+            "/threads/prune", json=payload, headers=headers, params=params
+        )
+
+    def get_state(
+        self,
+        thread_id: str,
+        checkpoint: Checkpoint | None = None,
+        checkpoint_id: str | None = None,  # deprecated
+        *,
+        subgraphs: bool = False,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> ThreadState:
+        """Get the state of a thread.
+
+        Args:
+            thread_id: The ID of the thread to get the state of.
+            checkpoint: The checkpoint to get the state of.
+            subgraphs: Include subgraphs states.
+            headers: Optional custom headers to include with the request.
+
+        Returns:
+            The thread of the state.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            thread_state = client.threads.get_state(
+                thread_id="my_thread_id",
+                checkpoint_id="my_checkpoint_id"
+            )
+            print(thread_state)
+            ```
+
+            ```shell
+            ----------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+            {
+                'values': {
+                    'messages': [
+                        {
+                            'content': 'how are you?',
+                            'additional_kwargs': {},
+                            'response_metadata': {},
+                            'type': 'human',
+                            'name': None,
+                            'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10',
+                            'example': False
+                        },
+                        {
+                            'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.",
+                            'additional_kwargs': {},
+                            'response_metadata': {},
+                            'type': 'ai',
+                            'name': None,
+                            'id': 'run-159b782c-b679-4830-83c6-cef87798fe8b',
+                            'example': False,
+                            'tool_calls': [],
+                            'invalid_tool_calls': [],
+                            'usage_metadata': None
+                        }
+                    ]
+                },
+                'next': [],
+                'checkpoint':
+                    {
+                        'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2',
+                        'checkpoint_ns': '',
+                        'checkpoint_id': '1ef4a9b8-e6fb-67b1-8001-abd5184439d1'
+                    }
+                'metadata':
+                    {
+                        'step': 1,
+                        'run_id': '1ef4a9b8-d7da-679a-a45a-872054341df2',
+                        'source': 'loop',
+                        'writes':
+                            {
+                                'agent':
+                                    {
+                                        'messages': [
+                                            {
+                                                'id': 'run-159b782c-b679-4830-83c6-cef87798fe8b',
+                                                'name': None,
+                                                'type': 'ai',
+                                                'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.",
+                                                'example': False,
+                                                'tool_calls': [],
+                                                'usage_metadata': None,
+                                                'additional_kwargs': {},
+                                                'response_metadata': {},
+                                                'invalid_tool_calls': []
+                                            }
+                                        ]
+                                    }
+                            },
+                'user_id': None,
+                'graph_id': 'agent',
+                'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2',
+                'created_by': 'system',
+                'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'},
+                'created_at': '2024-07-25T15:35:44.184703+00:00',
+                'parent_config':
+                    {
+                        'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2',
+                        'checkpoint_ns': '',
+                        'checkpoint_id': '1ef4a9b8-d80d-6fa7-8000-9300467fad0f'
+                    }
+            }
+            ```
+
+        """
+        if checkpoint:
+            return self.http.post(
+                f"/threads/{thread_id}/state/checkpoint",
+                json={"checkpoint": checkpoint, "subgraphs": subgraphs},
+                headers=headers,
+                params=params,
+            )
+        elif checkpoint_id:
+            get_params = {"subgraphs": subgraphs}
+            if params:
+                get_params = {**get_params, **params}
+            return self.http.get(
+                f"/threads/{thread_id}/state/{checkpoint_id}",
+                params=get_params,
+                headers=headers,
+            )
+        else:
+            get_params = {"subgraphs": subgraphs}
+            if params:
+                get_params = {**get_params, **params}
+            return self.http.get(
+                f"/threads/{thread_id}/state",
+                params=get_params,
+                headers=headers,
+            )
+
+    def update_state(
+        self,
+        thread_id: str,
+        values: dict[str, Any] | Sequence[dict] | None,
+        *,
+        as_node: str | None = None,
+        checkpoint: Checkpoint | None = None,
+        checkpoint_id: str | None = None,  # deprecated
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> ThreadUpdateStateResponse:
+        """Update the state of a thread.
+
+        Args:
+            thread_id: The ID of the thread to update.
+            values: The values to update the state with.
+            as_node: Update the state as if this node had just executed.
+            checkpoint: The checkpoint to update the state of.
+            headers: Optional custom headers to include with the request.
+
+        Returns:
+            Response after updating a thread's state.
+
+        ???+ example "Example Usage"
+
+            ```python
+
+            response = await client.threads.update_state(
+                thread_id="my_thread_id",
+                values={"messages":[{"role": "user", "content": "hello!"}]},
+                as_node="my_node",
+            )
+            print(response)
+
+            ----------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+            {
+                'checkpoint': {
+                    'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2',
+                    'checkpoint_ns': '',
+                    'checkpoint_id': '1ef4a9b8-e6fb-67b1-8001-abd5184439d1',
+                    'checkpoint_map': {}
+                }
+            }
+            ```
+
+        """
+        payload: dict[str, Any] = {
+            "values": values,
+        }
+        if checkpoint_id:
+            payload["checkpoint_id"] = checkpoint_id
+        if checkpoint:
+            payload["checkpoint"] = checkpoint
+        if as_node:
+            payload["as_node"] = as_node
+        return self.http.post(
+            f"/threads/{thread_id}/state", json=payload, headers=headers, params=params
+        )
+
+    def get_history(
+        self,
+        thread_id: str,
+        *,
+        limit: int = 10,
+        before: str | Checkpoint | None = None,
+        metadata: Mapping[str, Any] | None = None,
+        checkpoint: Checkpoint | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> list[ThreadState]:
+        """Get the state history of a thread.
+
+        Args:
+            thread_id: The ID of the thread to get the state history for.
+            checkpoint: Return states for this subgraph. If empty defaults to root.
+            limit: The maximum number of states to return.
+            before: Return states before this checkpoint.
+            metadata: Filter states by metadata key-value pairs.
+            headers: Optional custom headers to include with the request.
+
+        Returns:
+            The state history of the `Thread`.
+
+        ???+ example "Example Usage"
+
+            ```python
+
+            thread_state = client.threads.get_history(
+                thread_id="my_thread_id",
+                limit=5,
+                before="my_timestamp",
+                metadata={"name":"my_name"}
+            )
+            ```
+
+        """
+        payload: dict[str, Any] = {
+            "limit": limit,
+        }
+        if before:
+            payload["before"] = before
+        if metadata:
+            payload["metadata"] = metadata
+        if checkpoint:
+            payload["checkpoint"] = checkpoint
+        return self.http.post(
+            f"/threads/{thread_id}/history",
+            json=payload,
+            headers=headers,
+            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:
+            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)
+            ```
+
+        """
+        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,
+        )

libs/sdk-py/langgraph_sdk/schema.py

@@ -117,6 +117,13 @@ Specifies behavior if the thread doesn't exist:
 - "reject": Reject the operation if the thread doesn't exist.
 """
 
+PruneStrategy = Literal["delete", "keep_latest"]
+"""
+Strategy for pruning threads:
+- "delete": Remove threads entirely.
+- "keep_latest": Prune old checkpoints but keep threads and their latest state.
+"""
+
 CancelAction = Literal["interrupt", "rollback"]
 """
 Action to take when cancelling the run.
@@ -124,6 +131,14 @@ Action to take when cancelling the run.
 - "rollback": Cancel the run. Then delete the run and associated checkpoints.
 """
 
+BulkCancelRunsStatus = Literal["pending", "running", "all"]
+"""
+Filter runs by status when bulk-cancelling:
+- "pending": Cancel only pending runs.
+- "running": Cancel only running runs.
+- "all": Cancel all runs regardless of status.
+"""
+
 AssistantSortBy = Literal[
     "assistant_id", "graph_id", "name", "created_at", "updated_at"
 ]
@@ -137,7 +152,13 @@ The field to sort by.
 """
 
 CronSortBy = Literal[
-    "cron_id", "assistant_id", "thread_id", "created_at", "updated_at", "next_run_date"
+    "cron_id",
+    "assistant_id",
+    "thread_id",
+    "created_at",
+    "updated_at",
+    "next_run_date",
+    "end_time",
 ]
 """
 The field to sort by.

libs/sdk-py/pyproject.toml

@@ -30,10 +30,10 @@ test = [
     "pytest-watch",
 ]
 lint = [
-    "ruff==0.14.11",
+    "ruff==0.15.1",
     "codespell",
-    "mypy==1.19.0",
-    "ty==0.0.1a27",
+    "mypy==1.19.1",
+    "ty==0.0.17",
     "starlette",
 ]
 dev = [