chore: import upstream snapshot with attribution

libs/checkpoint-sqlite/tests/test_aiosqlite.py

@@ -0,0 +1,190 @@
+from typing import Any
+
+import pytest
+from langchain_core.runnables import RunnableConfig
+from langgraph.checkpoint.base import (
+    Checkpoint,
+    CheckpointMetadata,
+    create_checkpoint,
+    empty_checkpoint,
+)
+
+from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
+
+
+class TestAsyncSqliteSaver:
+    @pytest.fixture(autouse=True)
+    def setup(self) -> None:
+        # objects for test setup
+        self.config_1: RunnableConfig = {
+            "configurable": {
+                "thread_id": "thread-1",
+                "checkpoint_id": "1",
+                "checkpoint_ns": "",
+            }
+        }
+        self.config_2: RunnableConfig = {
+            "configurable": {
+                "thread_id": "thread-2",
+                "checkpoint_id": "2",
+                "checkpoint_ns": "",
+            }
+        }
+        self.config_3: RunnableConfig = {
+            "configurable": {
+                "thread_id": "thread-2",
+                "checkpoint_id": "2-inner",
+                "checkpoint_ns": "inner",
+            }
+        }
+
+        self.chkpnt_1: Checkpoint = empty_checkpoint()
+        self.chkpnt_2: Checkpoint = create_checkpoint(self.chkpnt_1, {}, 1)
+        self.chkpnt_3: Checkpoint = empty_checkpoint()
+
+        self.metadata_1: CheckpointMetadata = {
+            "source": "input",
+            "step": 2,
+            "writes": {},
+            "score": 1,
+        }
+        self.metadata_2: CheckpointMetadata = {
+            "source": "loop",
+            "step": 1,
+            "writes": {"foo": "bar"},
+            "score": None,
+        }
+        self.metadata_3: CheckpointMetadata = {}
+
+    async def test_combined_metadata(self) -> None:
+        async with AsyncSqliteSaver.from_conn_string(":memory:") as saver:
+            config: RunnableConfig = {
+                "configurable": {
+                    "thread_id": "thread-2",
+                    "checkpoint_ns": "",
+                    "__super_private_key": "super_private_value",
+                },
+                "metadata": {"run_id": "my_run_id"},
+            }
+            await saver.aput(config, self.chkpnt_2, self.metadata_2, {})
+            checkpoint = await saver.aget_tuple(config)
+            assert checkpoint is not None and checkpoint.metadata == {
+                **self.metadata_2,
+                "run_id": "my_run_id",
+            }
+
+    async def test_asearch(self) -> None:
+        async with AsyncSqliteSaver.from_conn_string(":memory:") as saver:
+            await saver.aput(self.config_1, self.chkpnt_1, self.metadata_1, {})
+            await saver.aput(self.config_2, self.chkpnt_2, self.metadata_2, {})
+            await saver.aput(self.config_3, self.chkpnt_3, self.metadata_3, {})
+
+            # call method / assertions
+            query_1 = {"source": "input"}  # search by 1 key
+            query_2 = {
+                "step": 1,
+                "writes": {"foo": "bar"},
+            }  # search by multiple keys
+            query_3: dict[str, Any] = {}  # search by no keys, return all checkpoints
+            query_4 = {"source": "update", "step": 1}  # no match
+
+            search_results_1 = [c async for c in saver.alist(None, filter=query_1)]
+            assert len(search_results_1) == 1
+            assert search_results_1[0].metadata == self.metadata_1
+
+            search_results_2 = [c async for c in saver.alist(None, filter=query_2)]
+            assert len(search_results_2) == 1
+            assert search_results_2[0].metadata == self.metadata_2
+
+            search_results_3 = [c async for c in saver.alist(None, filter=query_3)]
+            assert len(search_results_3) == 3
+
+            search_results_4 = [c async for c in saver.alist(None, filter=query_4)]
+            assert len(search_results_4) == 0
+
+            # search by config (defaults to checkpoints across all namespaces)
+            search_results_5 = [
+                c
+                async for c in saver.alist({"configurable": {"thread_id": "thread-2"}})
+            ]
+            assert len(search_results_5) == 2
+            assert {
+                search_results_5[0].config["configurable"]["checkpoint_ns"],
+                search_results_5[1].config["configurable"]["checkpoint_ns"],
+            } == {"", "inner"}
+
+            # Test limit param
+            search_results_6 = [
+                c
+                async for c in saver.alist(
+                    {"configurable": {"thread_id": "thread-2"}}, limit=1
+                )
+            ]
+            assert len(search_results_6) == 1
+            assert search_results_6[0].config["configurable"]["thread_id"] == "thread-2"
+
+            # Test before param
+            search_results_7 = [
+                c async for c in saver.alist(None, before=search_results_5[1].config)
+            ]
+            assert len(search_results_7) == 1
+            assert search_results_7[0].config["configurable"]["thread_id"] == "thread-1"
+
+    async def test_limit_parameter_sql_injection_prevention(self) -> None:
+        """Test that the limit parameter properly uses parameterized queries to prevent SQL injection."""
+        async with AsyncSqliteSaver.from_conn_string(":memory:") as saver:
+            # Setup: Create multiple checkpoints
+            for i in range(5):
+                config: RunnableConfig = {
+                    "configurable": {
+                        "thread_id": f"thread-{i}",
+                        "checkpoint_ns": "",
+                    }
+                }
+                checkpoint = empty_checkpoint()
+                metadata: CheckpointMetadata = {"index": i}
+                await saver.aput(config, checkpoint, metadata, {})
+
+            # Test that limit works correctly with valid integer
+            results = [c async for c in saver.alist(None, limit=2)]
+            assert len(results) == 2
+
+            # Test that limit=0 returns no results
+            results = [c async for c in saver.alist(None, limit=0)]
+            assert len(results) == 0
+
+            # Test that limit=None returns all results
+            results = [c async for c in saver.alist(None, limit=None)]
+            assert len(results) == 5
+
+            # Test explicit SQL injection attempt via limit parameter
+            # Even if type checking is bypassed and a malicious string is passed,
+            # the parameterized query will treat it as a value, not SQL code
+            # This would cause an error (can't convert string to int for LIMIT),
+            # which is the correct secure behavior
+            malicious_limits = [
+                "1; DROP TABLE checkpoints; --",
+                "1 OR 1=1",
+                "999999 UNION SELECT * FROM checkpoints",
+            ]
+
+            for malicious_limit in malicious_limits:
+                # The parameterized query should safely reject non-integer limits
+                # or convert them in a way that prevents SQL injection
+                try:
+                    # Bypass type checking by casting
+                    results = [
+                        c
+                        async for c in saver.alist(None, limit=malicious_limit)  # type: ignore
+                    ]
+                    # If it doesn't raise an error, it should at least not execute the injection
+                    # SQLite's parameter binding will try to convert the string to an integer
+                    # which will either fail or treat it as 0
+                except Exception:
+                    # Expected: SQLite should reject invalid limit values
+                    pass
+
+            # Verify the checkpoints table still exists and has all data
+            # (would have been dropped if injection succeeded)
+            results = [c async for c in saver.alist(None, limit=None)]
+            assert len(results) == 5

libs/checkpoint-sqlite/tests/test_async_store.py

@@ -0,0 +1,718 @@
+import asyncio
+import os
+import tempfile
+import uuid
+from collections.abc import AsyncIterator, Generator, Iterable
+from contextlib import asynccontextmanager
+from typing import cast
+
+import pytest
+from langgraph.store.base import (
+    GetOp,
+    Item,
+    ListNamespacesOp,
+    PutOp,
+    SearchOp,
+)
+
+from langgraph.store.sqlite import AsyncSqliteStore
+from langgraph.store.sqlite.base import SqliteIndexConfig
+from tests.test_store import CharacterEmbeddings
+
+
+@pytest.fixture(scope="function", params=["memory", "file"])
+async def store(request: pytest.FixtureRequest) -> AsyncIterator[AsyncSqliteStore]:
+    """Create an AsyncSqliteStore for testing."""
+    if request.param == "memory":
+        # In-memory store
+        async with AsyncSqliteStore.from_conn_string(":memory:") as store:
+            await store.setup()
+            yield store
+    else:
+        # Temporary file store
+        temp_file = tempfile.NamedTemporaryFile(delete=False)
+        temp_file.close()
+        try:
+            async with AsyncSqliteStore.from_conn_string(temp_file.name) as store:
+                await store.setup()
+                yield store
+        finally:
+            os.unlink(temp_file.name)
+
+
+@pytest.fixture(scope="function")
+def fake_embeddings() -> CharacterEmbeddings:
+    """Create fake embeddings for testing."""
+    return CharacterEmbeddings(dims=500)
+
+
+@asynccontextmanager
+async def create_vector_store(
+    fake_embeddings: CharacterEmbeddings,
+    conn_string: str = ":memory:",
+    text_fields: list[str] | None = None,
+) -> AsyncIterator[AsyncSqliteStore]:
+    """Create an AsyncSqliteStore with vector search capabilities."""
+    index_config: SqliteIndexConfig = {
+        "dims": fake_embeddings.dims,
+        "embed": fake_embeddings,
+        "text_fields": text_fields,
+    }
+
+    async with AsyncSqliteStore.from_conn_string(
+        conn_string, index=index_config
+    ) as store:
+        await store.setup()
+        yield store
+
+
+@pytest.fixture(scope="function", params=["memory", "file"])
+def conn_string(request: pytest.FixtureRequest) -> Generator[str, None, None]:
+    if request.param == "memory":
+        yield ":memory:"
+    else:
+        temp_file = tempfile.NamedTemporaryFile(delete=False)
+        temp_file.close()
+        try:
+            yield temp_file.name
+        finally:
+            os.unlink(temp_file.name)
+
+
+async def test_no_running_loop(store: AsyncSqliteStore) -> None:
+    """Test that sync methods raise proper errors in the main thread."""
+    with pytest.raises(asyncio.InvalidStateError):
+        store.put(("foo", "bar"), "baz", {"val": "baz"})
+    with pytest.raises(asyncio.InvalidStateError):
+        store.get(("foo", "bar"), "baz")
+    with pytest.raises(asyncio.InvalidStateError):
+        store.delete(("foo", "bar"), "baz")
+    with pytest.raises(asyncio.InvalidStateError):
+        store.search(("foo", "bar"))
+    with pytest.raises(asyncio.InvalidStateError):
+        store.list_namespaces(prefix=("foo",))
+    with pytest.raises(asyncio.InvalidStateError):
+        store.batch([PutOp(namespace=("foo", "bar"), key="baz", value={"val": "baz"})])
+
+
+async def test_large_batches_async(store: AsyncSqliteStore) -> None:
+    """Test processing large batch operations asynchronously."""
+    N = 100
+    M = 10
+    coros = []
+    for m in range(M):
+        for i in range(N):
+            coros.append(
+                store.aput(
+                    ("test", "foo", "bar", "baz", str(m % 2)),
+                    f"key{i}",
+                    value={"foo": "bar" + str(i)},
+                )
+            )
+            coros.append(
+                asyncio.create_task(
+                    store.aget(
+                        ("test", "foo", "bar", "baz", str(m % 2)),
+                        f"key{i}",
+                    )
+                )
+            )
+            coros.append(
+                asyncio.create_task(
+                    store.alist_namespaces(
+                        prefix=None,
+                        max_depth=m + 1,
+                    )
+                )
+            )
+            coros.append(
+                asyncio.create_task(
+                    store.asearch(
+                        ("test",),
+                    )
+                )
+            )
+            coros.append(
+                store.aput(
+                    ("test", "foo", "bar", "baz", str(m % 2)),
+                    f"key{i}",
+                    value={"foo": "bar" + str(i)},
+                )
+            )
+            coros.append(
+                store.adelete(
+                    ("test", "foo", "bar", "baz", str(m % 2)),
+                    f"key{i}",
+                )
+            )
+
+    results = await asyncio.gather(*coros)
+    assert len(results) == M * N * 6
+
+
+async def test_abatch_order(store: AsyncSqliteStore) -> None:
+    """Test ordering of batch operations in async context."""
+    # Setup test data
+    await store.aput(("test", "foo"), "key1", {"data": "value1"})
+    await store.aput(("test", "bar"), "key2", {"data": "value2"})
+
+    ops = [
+        GetOp(namespace=("test", "foo"), key="key1"),
+        PutOp(namespace=("test", "bar"), key="key2", value={"data": "value2"}),
+        SearchOp(
+            namespace_prefix=("test",), filter={"data": "value1"}, limit=10, offset=0
+        ),
+        ListNamespacesOp(match_conditions=None, max_depth=None, limit=10, offset=0),
+        GetOp(namespace=("test",), key="key3"),
+    ]
+
+    results = await store.abatch(
+        cast(Iterable[GetOp | PutOp | SearchOp | ListNamespacesOp], ops)
+    )
+    assert len(results) == 5
+    assert isinstance(results[0], Item)
+    assert isinstance(results[0].value, dict)
+    assert results[0].value == {"data": "value1"}
+    assert results[0].key == "key1"
+    assert results[1] is None  # Put operation returns None
+    assert isinstance(results[2], list)
+    # SQLite query implementation might return different results
+    # Just check that we get a list back and don't check the exact content
+    assert isinstance(results[3], list)
+    assert len(results[3]) > 0
+    assert results[4] is None  # Non-existent key returns None
+
+    # Test reordered operations
+    ops_reordered = [
+        SearchOp(namespace_prefix=("test",), filter=None, limit=5, offset=0),
+        GetOp(namespace=("test", "bar"), key="key2"),
+        ListNamespacesOp(match_conditions=None, max_depth=None, limit=5, offset=0),
+        PutOp(namespace=("test",), key="key3", value={"data": "value3"}),
+        GetOp(namespace=("test", "foo"), key="key1"),
+    ]
+
+    results_reordered = await store.abatch(
+        cast(Iterable[GetOp | PutOp | SearchOp | ListNamespacesOp], ops_reordered)
+    )
+    assert len(results_reordered) == 5
+    assert isinstance(results_reordered[0], list)
+    assert len(results_reordered[0]) >= 2  # Should find at least our two test items
+    assert isinstance(results_reordered[1], Item)
+    assert results_reordered[1].value == {"data": "value2"}
+    assert results_reordered[1].key == "key2"
+    assert isinstance(results_reordered[2], list)
+    assert len(results_reordered[2]) > 0
+    assert results_reordered[3] is None  # Put operation returns None
+    assert isinstance(results_reordered[4], Item)
+    assert results_reordered[4].value == {"data": "value1"}
+    assert results_reordered[4].key == "key1"
+
+
+async def test_batch_get_ops(store: AsyncSqliteStore) -> None:
+    """Test GET operations in batch context."""
+    # Setup test data
+    await store.aput(("test",), "key1", {"data": "value1"})
+    await store.aput(("test",), "key2", {"data": "value2"})
+
+    ops = [
+        GetOp(namespace=("test",), key="key1"),
+        GetOp(namespace=("test",), key="key2"),
+        GetOp(namespace=("test",), key="key3"),  # Non-existent key
+    ]
+
+    results = await store.abatch(ops)
+
+    assert len(results) == 3
+    assert results[0] is not None
+    assert results[1] is not None
+    assert results[2] is None
+    if results[0] is not None:
+        assert results[0].key == "key1"
+    if results[1] is not None:
+        assert results[1].key == "key2"
+
+
+async def test_batch_put_ops(store: AsyncSqliteStore) -> None:
+    """Test PUT operations in batch context."""
+    ops = [
+        PutOp(namespace=("test",), key="key1", value={"data": "value1"}),
+        PutOp(namespace=("test",), key="key2", value={"data": "value2"}),
+        PutOp(namespace=("test",), key="key3", value=None),  # Delete operation
+    ]
+
+    results = await store.abatch(ops)
+    assert len(results) == 3
+    assert all(result is None for result in results)
+
+    # Verify the puts worked
+    items = await store.asearch(("test",), limit=10)
+    assert len(items) == 2  # key3 had None value so wasn't stored
+
+
+async def test_batch_search_ops(store: AsyncSqliteStore) -> None:
+    """Test SEARCH operations in batch context."""
+    # Setup test data
+    await store.aput(("test", "foo"), "key1", {"data": "value1"})
+    await store.aput(("test", "bar"), "key2", {"data": "value2"})
+
+    ops = [
+        SearchOp(
+            namespace_prefix=("test",), filter={"data": "value1"}, limit=10, offset=0
+        ),
+        SearchOp(namespace_prefix=("test",), filter=None, limit=5, offset=0),
+    ]
+
+    results = await store.abatch(ops)
+
+    assert len(results) == 2
+    # SQLite query implementation might return different results
+    # Just check that we get lists back and don't check the exact content
+    assert isinstance(results[0], list)
+    assert isinstance(results[1], list)
+    assert len(results[1]) >= 1  # We should at least find some results
+
+
+async def test_batch_list_namespaces_ops(store: AsyncSqliteStore) -> None:
+    """Test LIST NAMESPACES operations in batch context."""
+    # Setup test data
+    await store.aput(("test", "namespace1"), "key1", {"data": "value1"})
+    await store.aput(("test", "namespace2"), "key2", {"data": "value2"})
+
+    ops = [ListNamespacesOp(match_conditions=None, max_depth=None, limit=10, offset=0)]
+
+    results = await store.abatch(ops)
+
+    assert len(results) == 1
+    if isinstance(results[0], list):
+        assert len(results[0]) == 2
+        assert ("test", "namespace1") in results[0]
+        assert ("test", "namespace2") in results[0]
+
+
+async def test_vector_store_initialization(
+    fake_embeddings: CharacterEmbeddings,
+) -> None:
+    """Test store initialization with embedding config."""
+    async with create_vector_store(fake_embeddings) as store:
+        assert store.index_config is not None
+        assert store.index_config["dims"] == fake_embeddings.dims
+        if hasattr(store.index_config.get("embed"), "embed_documents"):
+            assert store.index_config["embed"] == fake_embeddings
+
+
+async def test_vector_insert_with_auto_embedding(
+    fake_embeddings: CharacterEmbeddings,
+    conn_string: str,
+) -> None:
+    """Test inserting items that get auto-embedded."""
+    async with create_vector_store(fake_embeddings, conn_string=conn_string) as store:
+        docs = [
+            ("doc1", {"text": "short text"}),
+            ("doc2", {"text": "longer text document"}),
+            ("doc3", {"text": "longest text document here"}),
+            ("doc4", {"description": "text in description field"}),
+            ("doc5", {"content": "text in content field"}),
+            ("doc6", {"body": "text in body field"}),
+        ]
+
+        for key, value in docs:
+            await store.aput(("test",), key, value)
+
+        results = await store.asearch(("test",), query="long text")
+        assert len(results) > 0
+
+        doc_order = [r.key for r in results]
+        assert "doc2" in doc_order
+        assert "doc3" in doc_order
+
+
+async def test_vector_update_with_embedding(
+    fake_embeddings: CharacterEmbeddings,
+    conn_string: str,
+) -> None:
+    """Test that updating items properly updates their embeddings."""
+    async with create_vector_store(fake_embeddings, conn_string=conn_string) as store:
+        await store.aput(("test",), "doc1", {"text": "zany zebra Xerxes"})
+        await store.aput(("test",), "doc2", {"text": "something about dogs"})
+        await store.aput(("test",), "doc3", {"text": "text about birds"})
+
+        results_initial = await store.asearch(("test",), query="Zany Xerxes")
+        assert len(results_initial) > 0
+        assert results_initial[0].score is not None
+        assert results_initial[0].key == "doc1"
+        initial_score = results_initial[0].score
+
+        await store.aput(("test",), "doc1", {"text": "new text about dogs"})
+
+        results_after = await store.asearch(("test",), query="Zany Xerxes")
+        after_score = next((r.score for r in results_after if r.key == "doc1"), 0.0)
+        assert (
+            after_score is not None
+            and initial_score is not None
+            and after_score < initial_score
+        )
+
+        results_new = await store.asearch(("test",), query="new text about dogs")
+        for r in results_new:
+            if r.key == "doc1":
+                assert (
+                    r.score is not None
+                    and after_score is not None
+                    and r.score > after_score
+                )
+
+        # Don't index this one
+        await store.aput(
+            ("test",), "doc4", {"text": "new text about dogs"}, index=False
+        )
+        results_new = await store.asearch(
+            ("test",), query="new text about dogs", limit=3
+        )
+        assert not any(r.key == "doc4" for r in results_new)
+
+
+async def test_vector_search_with_filters(
+    fake_embeddings: CharacterEmbeddings,
+    conn_string: str,
+) -> None:
+    """Test combining vector search with filters."""
+    async with create_vector_store(fake_embeddings, conn_string=conn_string) as store:
+        docs = [
+            ("doc1", {"text": "red apple", "color": "red", "score": 4.5}),
+            ("doc2", {"text": "red car", "color": "red", "score": 3.0}),
+            ("doc3", {"text": "green apple", "color": "green", "score": 4.0}),
+            ("doc4", {"text": "blue car", "color": "blue", "score": 3.5}),
+        ]
+
+        for key, value in docs:
+            await store.aput(("test",), key, value)
+
+        # Vector search with filters can be inconsistent in test environments
+        # Skip asserting exact results as we've already validated the functionality
+        # in the synchronous tests
+        _ = await store.asearch(("test",), query="apple", filter={"color": "red"})
+
+        # Skip asserting exact results as we've already validated the functionality
+        # in the synchronous tests
+        _ = await store.asearch(("test",), query="car", filter={"color": "red"})
+
+        # Skip asserting exact results as we've already validated the functionality
+        # in the synchronous tests
+        _ = await store.asearch(
+            ("test",), query="bbbbluuu", filter={"score": {"$gt": 3.2}}
+        )
+
+        # Skip asserting exact results as we've already validated the functionality
+        # in the synchronous tests
+        _ = await store.asearch(
+            ("test",), query="apple", filter={"score": {"$gte": 4.0}, "color": "green"}
+        )
+
+
+async def test_vector_search_pagination(fake_embeddings: CharacterEmbeddings) -> None:
+    """Test pagination with vector search."""
+    async with create_vector_store(fake_embeddings) as store:
+        for i in range(5):
+            await store.aput(
+                ("test",), f"doc{i}", {"text": f"test document number {i}"}
+            )
+
+        results_page1 = await store.asearch(("test",), query="test", limit=2)
+        results_page2 = await store.asearch(("test",), query="test", limit=2, offset=2)
+
+        assert len(results_page1) == 2
+        assert len(results_page2) == 2
+        assert results_page1[0].key != results_page2[0].key
+
+        all_results = await store.asearch(("test",), query="test", limit=10)
+        assert len(all_results) == 5
+
+
+async def test_vector_search_edge_cases(fake_embeddings: CharacterEmbeddings) -> None:
+    """Test edge cases in vector search."""
+    async with create_vector_store(fake_embeddings) as store:
+        await store.aput(("test",), "doc1", {"text": "test document"})
+
+        results = await store.asearch(("test",), query="")
+        assert len(results) == 1
+
+        results = await store.asearch(("test",), query=None)
+        assert len(results) == 1
+
+        long_query = "test " * 100
+        results = await store.asearch(("test",), query=long_query)
+        assert len(results) == 1
+
+        special_query = "test!@#$%^&*()"
+        results = await store.asearch(("test",), query=special_query)
+        assert len(results) == 1
+
+
+async def test_embed_with_path(
+    fake_embeddings: CharacterEmbeddings,
+) -> None:
+    """Test vector search with specific text fields in SQLite store."""
+    async with create_vector_store(
+        fake_embeddings, text_fields=["key0", "key1", "key3"]
+    ) as store:
+        # This will have 2 vectors representing it
+        doc1 = {
+            # Omit key0 - check it doesn't raise an error
+            "key1": "xxx",
+            "key2": "yyy",
+            "key3": "zzz",
+        }
+        # This will have 3 vectors representing it
+        doc2 = {
+            "key0": "uuu",
+            "key1": "vvv",
+            "key2": "www",
+            "key3": "xxx",
+        }
+        await store.aput(("test",), "doc1", doc1)
+        await store.aput(("test",), "doc2", doc2)
+
+        # doc2.key3 and doc1.key1 both would have the highest score
+        results = await store.asearch(("test",), query="xxx")
+        assert len(results) == 2
+        assert results[0].key != results[1].key
+        assert results[0].score > 0.9
+        assert results[1].score > 0.9
+
+        # ~Only match doc2
+        results = await store.asearch(("test",), query="uuu")
+        assert len(results) == 2
+        assert results[0].key != results[1].key
+        assert results[0].key == "doc2"
+        assert results[0].score > results[1].score
+
+        # Un-indexed - will have low results for both. Not zero (because we're projecting)
+        # but less than the above.
+        results = await store.asearch(("test",), query="www")
+        assert len(results) == 2
+        assert results[0].score < 0.9
+        assert results[1].score < 0.9
+
+
+async def test_basic_store_ops(
+    fake_embeddings: CharacterEmbeddings,
+) -> None:
+    """Test vector search with specific text fields in SQLite store."""
+    async with create_vector_store(
+        fake_embeddings, text_fields=["key0", "key1", "key3"]
+    ) as store:
+        uid = uuid.uuid4().hex
+        namespace = (uid, "test", "documents")
+        item_id = "doc1"
+        item_value = {"title": "Test Document", "content": "Hello, World!"}
+        results = await store.asearch((uid,))
+        assert len(results) == 0
+
+        await store.aput(namespace, item_id, item_value)
+        item = await store.aget(namespace, item_id)
+
+        assert item is not None
+        assert item.namespace == namespace
+        assert item.key == item_id
+        assert item.value == item_value
+        assert item.created_at is not None
+        assert item.updated_at is not None
+
+        updated_value = {
+            "title": "Updated Test Document",
+            "content": "Hello, LangGraph!",
+        }
+        await asyncio.sleep(1.01)
+        await store.aput(namespace, item_id, updated_value)
+        updated_item = await store.aget(namespace, item_id)
+        assert updated_item is not None
+
+        assert updated_item.value == updated_value
+        assert updated_item.updated_at > item.updated_at
+        different_namespace = (uid, "test", "other_documents")
+        item_in_different_namespace = await store.aget(different_namespace, item_id)
+        assert item_in_different_namespace is None
+
+        new_item_id = "doc2"
+        new_item_value = {"title": "Another Document", "content": "Greetings!"}
+        await store.aput(namespace, new_item_id, new_item_value)
+
+        items = await store.asearch((uid, "test"), limit=10)
+        assert len(items) == 2
+        assert any(item.key == item_id for item in items)
+        assert any(item.key == new_item_id for item in items)
+
+        namespaces = await store.alist_namespaces(prefix=(uid, "test"))
+        assert (uid, "test", "documents") in namespaces
+
+        await store.adelete(namespace, item_id)
+        await store.adelete(namespace, new_item_id)
+        deleted_item = await store.aget(namespace, item_id)
+        assert deleted_item is None
+
+        deleted_item = await store.aget(namespace, new_item_id)
+        assert deleted_item is None
+
+        empty_search_results = await store.asearch((uid, "test"), limit=10)
+        assert len(empty_search_results) == 0
+
+
+async def test_list_namespaces(
+    fake_embeddings: CharacterEmbeddings,
+) -> None:
+    """Test list namespaces functionality with various filters."""
+    async with create_vector_store(
+        fake_embeddings, text_fields=["key0", "key1", "key3"]
+    ) as store:
+        test_pref = str(uuid.uuid4())
+        test_namespaces = [
+            (test_pref, "test", "documents", "public", test_pref),
+            (test_pref, "test", "documents", "private", test_pref),
+            (test_pref, "test", "images", "public", test_pref),
+            (test_pref, "test", "images", "private", test_pref),
+            (test_pref, "prod", "documents", "public", test_pref),
+            (test_pref, "prod", "documents", "some", "nesting", "public", test_pref),
+            (test_pref, "prod", "documents", "private", test_pref),
+        ]
+
+        # Add test data
+        for namespace in test_namespaces:
+            await store.aput(namespace, "dummy", {"content": "dummy"})
+
+        # Test prefix filtering
+        prefix_result = await store.alist_namespaces(prefix=(test_pref, "test"))
+        assert len(prefix_result) == 4
+        assert all(ns[1] == "test" for ns in prefix_result)
+
+        # Test specific prefix
+        specific_prefix_result = await store.alist_namespaces(
+            prefix=(test_pref, "test", "documents")
+        )
+        assert len(specific_prefix_result) == 2
+        assert all(ns[1:3] == ("test", "documents") for ns in specific_prefix_result)
+
+        # Test suffix filtering
+        suffix_result = await store.alist_namespaces(suffix=("public", test_pref))
+        assert len(suffix_result) == 4
+        assert all(ns[-2] == "public" for ns in suffix_result)
+
+        # Test combined prefix and suffix
+        prefix_suffix_result = await store.alist_namespaces(
+            prefix=(test_pref, "test"), suffix=("public", test_pref)
+        )
+        assert len(prefix_suffix_result) == 2
+        assert all(
+            ns[1] == "test" and ns[-2] == "public" for ns in prefix_suffix_result
+        )
+
+        # Test wildcard in prefix
+        wildcard_prefix_result = await store.alist_namespaces(
+            prefix=(test_pref, "*", "documents")
+        )
+        assert len(wildcard_prefix_result) == 5
+        assert all(ns[2] == "documents" for ns in wildcard_prefix_result)
+
+        # Test wildcard in suffix
+        wildcard_suffix_result = await store.alist_namespaces(
+            suffix=("*", "public", test_pref)
+        )
+        assert len(wildcard_suffix_result) == 4
+        assert all(ns[-2] == "public" for ns in wildcard_suffix_result)
+
+        wildcard_single = await store.alist_namespaces(
+            suffix=("some", "*", "public", test_pref)
+        )
+        assert len(wildcard_single) == 1
+        assert wildcard_single[0] == (
+            test_pref,
+            "prod",
+            "documents",
+            "some",
+            "nesting",
+            "public",
+            test_pref,
+        )
+
+        # Test max depth
+        max_depth_result = await store.alist_namespaces(max_depth=3)
+        assert all(len(ns) <= 3 for ns in max_depth_result)
+
+        max_depth_result = await store.alist_namespaces(
+            max_depth=4, prefix=(test_pref, "*", "documents")
+        )
+        assert len(set(res for res in max_depth_result)) == len(max_depth_result) == 5
+
+        # Test pagination
+        limit_result = await store.alist_namespaces(prefix=(test_pref,), limit=3)
+        assert len(limit_result) == 3
+
+        offset_result = await store.alist_namespaces(prefix=(test_pref,), offset=3)
+        assert len(offset_result) == len(test_namespaces) - 3
+
+        empty_prefix_result = await store.alist_namespaces(prefix=(test_pref,))
+        assert len(empty_prefix_result) == len(test_namespaces)
+        assert set(empty_prefix_result) == set(test_namespaces)
+
+        # Clean up
+        for namespace in test_namespaces:
+            await store.adelete(namespace, "dummy")
+
+
+async def test_search_items(
+    fake_embeddings: CharacterEmbeddings,
+) -> None:
+    """Test search_items functionality by calling store methods directly."""
+    base = "test_search_items"
+    test_namespaces = [
+        (base, "documents", "user1"),
+        (base, "documents", "user2"),
+        (base, "reports", "department1"),
+        (base, "reports", "department2"),
+    ]
+    test_items = [
+        {"title": "Doc 1", "author": "John Doe", "tags": ["important"]},
+        {"title": "Doc 2", "author": "Jane Smith", "tags": ["draft"]},
+        {"title": "Report A", "author": "John Doe", "tags": ["final"]},
+        {"title": "Report B", "author": "Alice Johnson", "tags": ["draft"]},
+    ]
+
+    async with create_vector_store(
+        fake_embeddings, text_fields=["key0", "key1", "key3"]
+    ) as store:
+        # Insert test data
+        for ns, item in zip(test_namespaces, test_items, strict=False):
+            key = f"item_{ns[-1]}"
+            await store.aput(ns, key, item)
+
+        # 1. Search documents
+        docs = await store.asearch((base, "documents"))
+        assert len(docs) == 2
+        assert all(item.namespace[1] == "documents" for item in docs)
+
+        # 2. Search reports
+        reports = await store.asearch((base, "reports"))
+        assert len(reports) == 2
+        assert all(item.namespace[1] == "reports" for item in reports)
+
+        # 3. Pagination
+        first_page = await store.asearch((base,), limit=2, offset=0)
+        second_page = await store.asearch((base,), limit=2, offset=2)
+        assert len(first_page) == 2
+        assert len(second_page) == 2
+        keys_page1 = {item.key for item in first_page}
+        keys_page2 = {item.key for item in second_page}
+        assert keys_page1.isdisjoint(keys_page2)
+        all_items = await store.asearch((base,))
+        assert len(all_items) == 4
+
+        john_items = await store.asearch((base,), filter={"author": "John Doe"})
+        assert len(john_items) == 2
+        assert all(item.value["author"] == "John Doe" for item in john_items)
+
+        draft_items = await store.asearch((base,), filter={"tags": ["draft"]})
+        assert len(draft_items) == 2
+        assert all("draft" in item.value["tags"] for item in draft_items)
+
+        for ns in test_namespaces:
+            key = f"item_{ns[-1]}"
+            await store.adelete(ns, key)

libs/checkpoint-sqlite/tests/test_conformance_delta.py

@@ -0,0 +1,35 @@
+"""Run delta-channel conformance capabilities against AsyncSqliteSaver."""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip(
+    "langgraph.checkpoint.conformance",
+    reason="langgraph-checkpoint-conformance not installed",
+)
+pytest.importorskip("aiosqlite", reason="aiosqlite not installed")
+
+
+@pytest.mark.asyncio
+async def test_delta_channel_conformance():
+    from langgraph.checkpoint.conformance import validate
+    from langgraph.checkpoint.conformance.initializer import checkpointer_test
+
+    from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
+
+    @checkpointer_test(name="AsyncSqliteSaver")
+    async def sqlite_saver():
+        async with AsyncSqliteSaver.from_conn_string(":memory:") as saver:
+            yield saver
+
+    report = await validate(
+        sqlite_saver,
+        capabilities={
+            "delta_channel_history",
+        },
+    )
+    for cap, result in report.results.items():
+        if result.passed is False:
+            details = "\n".join(result.failures or [])
+            pytest.fail(f"Capability {cap} failed:\n{details}")

libs/checkpoint-sqlite/tests/test_delta_channel_migration.py

@@ -0,0 +1,170 @@
+"""Sqlite-specific migration smoke tests: BinaryOperatorAggregate -> DeltaChannel.
+
+Mirrors `libs/langgraph/tests/test_delta_channel_migration.py` (which
+covers `InMemorySaver` + a third-party fallback to the base default
+impl). This file exercises the same migration scenario through the
+sqlite-specific `SqliteSaver.get_delta_channel_history` override —
+specifically that the streaming ancestor walk finds a pre-migration
+plain `channel_values[ch]` entry and surfaces it as the `seed`, with
+post-migration writes folding on top through the reducer.
+
+Pre-migration checkpoints under `BinaryOperatorAggregate` carry the
+full accumulated value at every settled super-step boundary. The
+override has to identify those as "real" seeds (not `_DeltaSnapshot`
+sentinels) — the saver layer is intentionally delta-agnostic and just
+returns whatever is stored in `channel_values[ch]`.
+"""
+
+from __future__ import annotations
+
+import operator
+from typing import Annotated, Any
+
+import pytest
+from langchain_core.runnables import RunnableConfig
+
+# `langgraph` core isn't a dep of `langgraph-checkpoint-sqlite`. Skip the
+# whole module rather than importerror-ing in the standalone CI shape.
+pytest.importorskip("langgraph.channels.delta", reason="langgraph core not installed")
+pytest.importorskip("langgraph.channels.binop", reason="langgraph core not installed")
+pytest.importorskip("langgraph.graph", reason="langgraph core not installed")
+
+from langgraph.channels.binop import BinaryOperatorAggregate  # type: ignore[import-untyped]  # noqa: E402,I001
+from langgraph.channels.delta import DeltaChannel  # type: ignore[import-untyped]  # noqa: E402
+from langgraph.graph import END, START, StateGraph  # type: ignore[import-untyped]  # noqa: E402
+from typing_extensions import TypedDict  # noqa: E402
+
+from langgraph.checkpoint.sqlite import SqliteSaver  # noqa: E402
+from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver  # noqa: E402
+
+pytestmark = pytest.mark.anyio
+
+
+def _noop(_state: Any) -> dict:
+    return {}
+
+
+def _list_concat(state: list, writes: list) -> list:
+    result = list(state)
+    for w in writes:
+        result.extend(w if isinstance(w, list) else [w])
+    return result
+
+
+def _binop_graph(checkpointer: Any) -> Any:
+    class BinopState(TypedDict):
+        items: Annotated[list, BinaryOperatorAggregate(list, operator.add)]
+
+    return (
+        StateGraph(BinopState)
+        .add_node("noop", _noop)
+        .add_edge(START, "noop")
+        .add_edge("noop", END)
+        .compile(checkpointer=checkpointer)
+    )
+
+
+def _delta_graph(checkpointer: Any) -> Any:
+    class DeltaState(TypedDict):
+        items: Annotated[list, DeltaChannel(_list_concat)]
+
+    return (
+        StateGraph(DeltaState)
+        .add_node("noop", _noop)
+        .add_edge(START, "noop")
+        .add_edge("noop", END)
+        .compile(checkpointer=checkpointer)
+    )
+
+
+def _drive(graph: Any, config: RunnableConfig, tag: str, n: int) -> None:
+    for i in range(n):
+        graph.invoke({"items": [f"{tag}{i}"]}, config)
+
+
+async def _adrive(graph: Any, config: RunnableConfig, tag: str, n: int) -> None:
+    for i in range(n):
+        await graph.ainvoke({"items": [f"{tag}{i}"]}, config)
+
+
+def _settled_boundaries(history: list) -> list[tuple[RunnableConfig, list]]:
+    """`(config, items)` for every checkpoint with `next == ('__start__',)`
+    — the stable inter-invoke boundaries that round-trip predictably.
+    """
+    return [
+        (s.config, list(s.values.get("items", [])))
+        for s in history
+        if s.next == ("__start__",)
+    ]
+
+
+def test_migration_preserves_pre_migration_state_sync() -> None:
+    """Drive 3 invokes under `BinaryOperatorAggregate`, swap the
+    annotation to `DeltaChannel` on the same sqlite-backed thread, and
+    verify every settled pre-migration boundary round-trips exactly.
+
+    The override's streaming walk must identify the plain accumulated
+    list at each pre-migration ancestor as a valid `seed` even though
+    no `_DeltaSnapshot` was ever written there.
+    """
+    with SqliteSaver.from_conn_string(":memory:") as saver:
+        config: RunnableConfig = {"configurable": {"thread_id": "mig-sync"}}
+
+        binop = _binop_graph(saver)
+        _drive(binop, config, "u", 3)
+
+        pre_boundaries = _settled_boundaries(list(binop.get_state_history(config)))
+        assert len(pre_boundaries) >= 2, "expected multiple settled boundaries"
+
+        delta = _delta_graph(saver)
+        for cfg, items in pre_boundaries:
+            snap = delta.get_state(cfg)
+            assert list(snap.values.get("items", [])) == items, (
+                f"snapshot mismatch at {cfg['configurable']['checkpoint_id']}: "
+                f"expected {items}, got {snap.values.get('items', [])}"
+            )
+
+
+def test_migration_continued_thread_folds_deltas_on_seed_sync() -> None:
+    """After migration, driving one more super-step extends the
+    pre-migration accumulated state via the delta reducer — the seed
+    plus a single new write.
+    """
+    with SqliteSaver.from_conn_string(":memory:") as saver:
+        config: RunnableConfig = {"configurable": {"thread_id": "mig-continue-sync"}}
+
+        binop = _binop_graph(saver)
+        _drive(binop, config, "u", 3)
+
+        pre_history = list(binop.get_state_history(config))
+        pre_boundaries = _settled_boundaries(pre_history)
+        # Latest settled boundary — the leaf pre-migration state.
+        leaf_cfg, leaf_items = pre_boundaries[0]
+        assert leaf_items, "expected non-empty pre-migration leaf"
+
+        delta = _delta_graph(saver)
+        delta.invoke({"items": ["after-migration"]}, leaf_cfg)
+        new_state = delta.get_state(config).values["items"]
+        assert new_state[: len(leaf_items)] == leaf_items
+        assert "after-migration" in new_state
+
+
+async def test_migration_preserves_pre_migration_state_async() -> None:
+    """Async equivalent of the basic-migration round-trip check on
+    `AsyncSqliteSaver`."""
+    async with AsyncSqliteSaver.from_conn_string(":memory:") as saver:
+        config: RunnableConfig = {"configurable": {"thread_id": "mig-async"}}
+
+        binop = _binop_graph(saver)
+        await _adrive(binop, config, "u", 3)
+
+        pre_history = [s async for s in binop.aget_state_history(config)]
+        pre_boundaries = _settled_boundaries(pre_history)
+        assert len(pre_boundaries) >= 2
+
+        delta = _delta_graph(saver)
+        for cfg, items in pre_boundaries:
+            snap = await delta.aget_state(cfg)
+            assert list(snap.values.get("items", [])) == items, (
+                f"async snapshot mismatch at {cfg['configurable']['checkpoint_id']}"
+            )

libs/checkpoint-sqlite/tests/test_get_delta_channel_history.py

@@ -0,0 +1,271 @@
+"""Smoke tests for `BaseCheckpointSaver.get_delta_channel_history` on sqlite.
+
+`SqliteSaver` (and `AsyncSqliteSaver`) deliberately don't override the
+default implementation in `BaseCheckpointSaver` — these tests pin the
+default impl to behave correctly end-to-end against a real persistent
+saver and a real `DeltaChannel`-backed graph.
+
+Scenarios covered:
+
+* Empty `channels` argument returns an empty mapping (no I/O).
+* On a non-trivial multi-checkpoint thread, per-channel writes come back
+  oldest→newest.
+* When the walk reaches the root without ever finding a stored value,
+  `seed` is omitted from the entry (consumer treats absence as "start
+  empty").
+* When a `_DeltaSnapshot` blob is present at an ancestor, it is returned
+  as the `seed`.
+* The async saver returns the same shape via `aget_delta_channel_history`.
+"""
+
+from __future__ import annotations
+
+import operator
+from typing import Annotated, Any
+
+import pytest
+from langchain_core.runnables import RunnableConfig
+
+# `langgraph` is not a dep of `langgraph-checkpoint-sqlite`. When tests run
+# in the sqlite lib's standalone CI environment without it installed, skip
+# the whole module rather than failing at import.
+pytest.importorskip("langgraph.channels.delta", reason="langgraph core not installed")
+pytest.importorskip("langgraph.graph", reason="langgraph core not installed")
+
+from langgraph.channels.delta import DeltaChannel  # type: ignore[import-untyped]  # noqa: E402,I001
+from langgraph.checkpoint.serde.types import _DeltaSnapshot  # noqa: E402
+from langgraph.graph import END, START, StateGraph  # type: ignore[import-untyped]  # noqa: E402
+from typing_extensions import TypedDict  # noqa: E402
+
+from langgraph.checkpoint.sqlite import SqliteSaver  # noqa: E402
+from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver  # noqa: E402
+
+pytestmark = pytest.mark.anyio
+
+
+# ---------------------------------------------------------------------------
+# Graph helpers
+# ---------------------------------------------------------------------------
+
+
+def _noop(_state: Any) -> dict[str, Any]:
+    return {}
+
+
+class _DeltaState(TypedDict):
+    items: Annotated[list, DeltaChannel(operator.add)]
+
+
+def _delta_graph(checkpointer: Any) -> Any:
+    return (
+        StateGraph(_DeltaState)
+        .add_node("noop", _noop)
+        .add_edge(START, "noop")
+        .add_edge("noop", END)
+        .compile(checkpointer=checkpointer)
+    )
+
+
+def _drive(graph: Any, config: RunnableConfig, n: int) -> None:
+    for i in range(n):
+        graph.invoke({"items": [f"v{i}"]}, config)
+
+
+async def _adrive(graph: Any, config: RunnableConfig, n: int) -> None:
+    for i in range(n):
+        await graph.ainvoke({"items": [f"v{i}"]}, config)
+
+
+def _pick_non_root(saver: Any, config: RunnableConfig) -> RunnableConfig:
+    """Return a config pointing at a checkpoint that has at least one ancestor.
+
+    `get_delta_channel_history` walks the parent chain — calling it on the root
+    checkpoint produces `writes=[]` and no `seed`, which is uninteresting
+    for the multi-step assertions below.
+    """
+    history = list(saver.list(config))
+    assert history, "expected non-empty history"
+    # `list` yields newest→oldest; the second entry has the first entry
+    # as its parent, so its parent_config is non-None.
+    for tup in history:
+        if tup.parent_config is not None:
+            return tup.config
+    raise AssertionError("no checkpoint with a parent in history")
+
+
+async def _apick_non_root(saver: Any, config: RunnableConfig) -> RunnableConfig:
+    history = [tup async for tup in saver.alist(config)]
+    assert history, "expected non-empty history"
+    for tup in history:
+        if tup.parent_config is not None:
+            return tup.config
+    raise AssertionError("no checkpoint with a parent in history")
+
+
+# ---------------------------------------------------------------------------
+# Sync: SqliteSaver
+# ---------------------------------------------------------------------------
+
+
+def test_empty_channels_returns_empty_mapping_sync() -> None:
+    """Empty `channels` short-circuits to `{}` without touching storage."""
+    with SqliteSaver.from_conn_string(":memory:") as saver:
+        config: RunnableConfig = {"configurable": {"thread_id": "empty"}}
+        assert saver.get_delta_channel_history(config=config, channels=[]) == {}
+
+
+def test_writes_history_oldest_to_newest_sync() -> None:
+    """Per-channel writes accumulated across the walk come back oldest→newest."""
+    with SqliteSaver.from_conn_string(":memory:") as saver:
+        config: RunnableConfig = {"configurable": {"thread_id": "history-sync"}}
+        graph = _delta_graph(saver)
+        _drive(graph, config, 3)
+
+        target_cfg = _pick_non_root(saver, config)
+        result = saver.get_delta_channel_history(config=target_cfg, channels=["items"])
+
+        assert "items" in result
+        entry = result["items"]
+        assert isinstance(entry["writes"], list)
+
+        # If any writes were collected, their values should be in oldest→newest
+        # order — i.e. tagged 'v0', 'v1', ... matching invoke order.
+        write_values: list[Any] = []
+        for _task_id, channel, value in entry["writes"]:
+            assert channel == "items"
+            write_values.extend(value if isinstance(value, list) else [value])
+
+        # `_drive` invokes with payloads ['v0'], ['v1'], ['v2']. Whatever
+        # subset shows up in the chain must be a contiguous prefix in order.
+        for idx, val in enumerate(write_values):
+            assert val == f"v{idx}", (
+                f"writes not in oldest→newest order: {write_values}"
+            )
+
+
+def test_seed_present_when_snapshot_in_ancestor_sync() -> None:
+    """Inserting a `_DeltaSnapshot` blob at an ancestor → walk returns it as `seed`."""
+    with SqliteSaver.from_conn_string(":memory:") as saver:
+        config: RunnableConfig = {"configurable": {"thread_id": "seed-sync"}}
+        graph = _delta_graph(saver)
+        _drive(graph, config, 2)
+
+        # Find the oldest non-root checkpoint, then walk to its parent and
+        # rewrite that parent's `channel_values["items"]` to a real
+        # `_DeltaSnapshot`. After this surgery, calling `get_delta_channel_history`
+        # at the leaf must return the snapshot value as `seed`.
+        history = list(saver.list(config))
+        assert len(history) >= 2
+        leaf_tup = history[0]
+        # Walk to an ancestor with a parent_config (any non-root will do).
+        ancestor_tup = next(
+            (tup for tup in history if tup.parent_config is not None), None
+        )
+        assert ancestor_tup is not None
+        parent_cfg = ancestor_tup.parent_config
+        assert parent_cfg is not None
+        parent_tup = saver.get_tuple(parent_cfg)
+        assert parent_tup is not None
+
+        snapshot_value = ["seeded", "items"]
+        parent_tup.checkpoint["channel_values"]["items"] = _DeltaSnapshot(
+            snapshot_value
+        )
+        # Make sure the channel has a version so the optimized blob lookup
+        # in any future override has something to hit.
+        parent_tup.checkpoint["channel_versions"].setdefault("items", 1)
+        saver.put(
+            parent_tup.parent_config or {"configurable": parent_cfg["configurable"]},
+            parent_tup.checkpoint,
+            parent_tup.metadata,
+            {},
+        )
+
+        result = saver.get_delta_channel_history(
+            config=leaf_tup.config, channels=["items"]
+        )
+        entry = result["items"]
+        assert "seed" in entry, f"expected seed to be present, got {entry}"
+        seed = entry["seed"]
+        assert isinstance(seed, _DeltaSnapshot), (
+            f"expected _DeltaSnapshot, got {seed!r}"
+        )
+        assert seed.value == snapshot_value
+
+
+def test_seed_omitted_when_walk_reaches_root_sync() -> None:
+    """`get_delta_channel_history` on the root checkpoint → no `seed` key, no writes."""
+    with SqliteSaver.from_conn_string(":memory:") as saver:
+        config: RunnableConfig = {"configurable": {"thread_id": "root-sync"}}
+        graph = _delta_graph(saver)
+        _drive(graph, config, 1)
+
+        history = list(saver.list(config))
+        # Root is the oldest checkpoint (no parent_config).
+        root_tup = history[-1]
+        assert root_tup.parent_config is None
+
+        result = saver.get_delta_channel_history(
+            config=root_tup.config, channels=["items"]
+        )
+        entry = result["items"]
+        assert "seed" not in entry, f"root-walk should have no seed, got {entry}"
+        assert entry["writes"] == []
+
+
+# ---------------------------------------------------------------------------
+# Async: AsyncSqliteSaver
+# ---------------------------------------------------------------------------
+
+
+async def test_empty_channels_returns_empty_mapping_async() -> None:
+    """Async equivalent of the empty-channels short-circuit."""
+    async with AsyncSqliteSaver.from_conn_string(":memory:") as saver:
+        config: RunnableConfig = {"configurable": {"thread_id": "empty-async"}}
+        assert await saver.aget_delta_channel_history(config=config, channels=[]) == {}
+
+
+async def test_writes_history_oldest_to_newest_async() -> None:
+    """Async equivalent of the oldest→newest ordering check."""
+    async with AsyncSqliteSaver.from_conn_string(":memory:") as saver:
+        config: RunnableConfig = {"configurable": {"thread_id": "history-async"}}
+        graph = _delta_graph(saver)
+        await _adrive(graph, config, 3)
+
+        target_cfg = await _apick_non_root(saver, config)
+        result = await saver.aget_delta_channel_history(
+            config=target_cfg, channels=["items"]
+        )
+
+        assert "items" in result
+        entry = result["items"]
+        assert isinstance(entry["writes"], list)
+
+        write_values: list[Any] = []
+        for _task_id, channel, value in entry["writes"]:
+            assert channel == "items"
+            write_values.extend(value if isinstance(value, list) else [value])
+
+        for idx, val in enumerate(write_values):
+            assert val == f"v{idx}", (
+                f"writes not in oldest→newest order: {write_values}"
+            )
+
+
+async def test_seed_omitted_when_walk_reaches_root_async() -> None:
+    """Async equivalent of the root-walk seed-absence check."""
+    async with AsyncSqliteSaver.from_conn_string(":memory:") as saver:
+        config: RunnableConfig = {"configurable": {"thread_id": "root-async"}}
+        graph = _delta_graph(saver)
+        await _adrive(graph, config, 1)
+
+        history = [tup async for tup in saver.alist(config)]
+        root_tup = history[-1]
+        assert root_tup.parent_config is None
+
+        result = await saver.aget_delta_channel_history(
+            config=root_tup.config, channels=["items"]
+        )
+        entry = result["items"]
+        assert "seed" not in entry, f"root-walk should have no seed, got {entry}"
+        assert entry["writes"] == []

libs/checkpoint-sqlite/tests/test_sqlite.py

@@ -0,0 +1,309 @@
+from typing import Any, cast
+
+import pytest
+from langchain_core.runnables import RunnableConfig
+from langgraph.checkpoint.base import (
+    Checkpoint,
+    CheckpointMetadata,
+    create_checkpoint,
+    empty_checkpoint,
+)
+
+from langgraph.checkpoint.sqlite import SqliteSaver
+from langgraph.checkpoint.sqlite.utils import _metadata_predicate, search_where
+
+
+class TestSqliteSaver:
+    @pytest.fixture(autouse=True)
+    def setup(self) -> None:
+        # objects for test setup
+        self.config_1: RunnableConfig = {
+            "configurable": {
+                "thread_id": "thread-1",
+                # for backwards compatibility testing
+                "checkpoint_id": "1",
+                "checkpoint_ns": "",
+            }
+        }
+        self.config_2: RunnableConfig = {
+            "configurable": {
+                "thread_id": "thread-2",
+                "checkpoint_id": "2",
+                "checkpoint_ns": "",
+            }
+        }
+        self.config_3: RunnableConfig = {
+            "configurable": {
+                "thread_id": "thread-2",
+                "checkpoint_id": "2-inner",
+                "checkpoint_ns": "inner",
+            }
+        }
+
+        self.chkpnt_1: Checkpoint = empty_checkpoint()
+        self.chkpnt_2: Checkpoint = create_checkpoint(self.chkpnt_1, {}, 1)
+        self.chkpnt_3: Checkpoint = empty_checkpoint()
+
+        self.metadata_1: CheckpointMetadata = {
+            "source": "input",
+            "step": 2,
+            "writes": {},
+            "score": 1,
+        }
+        self.metadata_2: CheckpointMetadata = {
+            "source": "loop",
+            "step": 1,
+            "writes": {"foo": "bar"},
+            "score": None,
+        }
+        self.metadata_3: CheckpointMetadata = {}
+
+    def test_combined_metadata(self) -> None:
+        with SqliteSaver.from_conn_string(":memory:") as saver:
+            config: RunnableConfig = {
+                "configurable": {
+                    "thread_id": "thread-2",
+                    "checkpoint_ns": "",
+                    "__super_private_key": "super_private_value",
+                },
+                "metadata": {"run_id": "my_run_id"},
+            }
+            saver.put(config, self.chkpnt_2, self.metadata_2, {})
+            checkpoint = saver.get_tuple(config)
+            assert checkpoint is not None and checkpoint.metadata == {
+                **self.metadata_2,
+                "run_id": "my_run_id",
+            }
+
+    def test_search(self) -> None:
+        with SqliteSaver.from_conn_string(":memory:") as saver:
+            # set up test
+            # save checkpoints
+            saver.put(self.config_1, self.chkpnt_1, self.metadata_1, {})
+            saver.put(self.config_2, self.chkpnt_2, self.metadata_2, {})
+            saver.put(self.config_3, self.chkpnt_3, self.metadata_3, {})
+
+            # call method / assertions
+            query_1 = {"source": "input"}  # search by 1 key
+            query_2 = {
+                "step": 1,
+                "writes": {"foo": "bar"},
+            }  # search by multiple keys
+            query_3: dict[str, Any] = {}  # search by no keys, return all checkpoints
+            query_4 = {"source": "update", "step": 1}  # no match
+
+            search_results_1 = list(saver.list(None, filter=query_1))
+            assert len(search_results_1) == 1
+            assert search_results_1[0].metadata == self.metadata_1
+
+            search_results_2 = list(saver.list(None, filter=query_2))
+            assert len(search_results_2) == 1
+            assert search_results_2[0].metadata == self.metadata_2
+
+            search_results_3 = list(saver.list(None, filter=query_3))
+            assert len(search_results_3) == 3
+
+            search_results_4 = list(saver.list(None, filter=query_4))
+            assert len(search_results_4) == 0
+
+            # search by config (defaults to checkpoints across all namespaces)
+            search_results_5 = list(
+                saver.list({"configurable": {"thread_id": "thread-2"}})
+            )
+            assert len(search_results_5) == 2
+            assert {
+                search_results_5[0].config["configurable"]["checkpoint_ns"],
+                search_results_5[1].config["configurable"]["checkpoint_ns"],
+            } == {"", "inner"}
+
+            # search with before param
+            search_results_6 = list(saver.list(None, before=search_results_5[1].config))
+            assert len(search_results_6) == 1
+            assert search_results_6[0].config["configurable"]["thread_id"] == "thread-1"
+
+            # search with limit param
+            search_results_7 = list(
+                saver.list({"configurable": {"thread_id": "thread-2"}}, limit=1)
+            )
+            assert len(search_results_7) == 1
+            assert search_results_7[0].config["configurable"]["thread_id"] == "thread-2"
+
+    def test_search_where(self) -> None:
+        # call method / assertions
+        expected_predicate_1 = "WHERE json_extract(CAST(metadata AS TEXT), '$.source') = ? AND json_extract(CAST(metadata AS TEXT), '$.step') = ? AND json_extract(CAST(metadata AS TEXT), '$.writes') = ? AND json_extract(CAST(metadata AS TEXT), '$.score') = ? AND checkpoint_id < ?"
+        expected_param_values_1 = ["input", 2, "{}", 1, "1"]
+        assert search_where(
+            None, cast(dict[str, Any], self.metadata_1), self.config_1
+        ) == (
+            expected_predicate_1,
+            expected_param_values_1,
+        )
+
+    def test_metadata_predicate(self) -> None:
+        # call method / assertions
+        expected_predicate_1 = [
+            "json_extract(CAST(metadata AS TEXT), '$.source') = ?",
+            "json_extract(CAST(metadata AS TEXT), '$.step') = ?",
+            "json_extract(CAST(metadata AS TEXT), '$.writes') = ?",
+            "json_extract(CAST(metadata AS TEXT), '$.score') = ?",
+        ]
+        expected_predicate_2 = [
+            "json_extract(CAST(metadata AS TEXT), '$.source') = ?",
+            "json_extract(CAST(metadata AS TEXT), '$.step') = ?",
+            "json_extract(CAST(metadata AS TEXT), '$.writes') = ?",
+            "json_extract(CAST(metadata AS TEXT), '$.score') IS ?",
+        ]
+        expected_predicate_3: list[str] = []
+
+        expected_param_values_1 = ["input", 2, "{}", 1]
+        expected_param_values_2 = ["loop", 1, '{"foo":"bar"}', None]
+        expected_param_values_3: list[Any] = []
+
+        assert _metadata_predicate(cast(dict[str, Any], self.metadata_1)) == (
+            expected_predicate_1,
+            expected_param_values_1,
+        )
+        assert _metadata_predicate(cast(dict[str, Any], self.metadata_2)) == (
+            expected_predicate_2,
+            expected_param_values_2,
+        )
+        assert _metadata_predicate(cast(dict[str, Any], self.metadata_3)) == (
+            expected_predicate_3,
+            expected_param_values_3,
+        )
+
+    async def test_informative_async_errors(self) -> None:
+        with SqliteSaver.from_conn_string(":memory:") as saver:
+            # call method / assertions
+            with pytest.raises(NotImplementedError, match="AsyncSqliteSaver"):
+                await saver.aget(self.config_1)
+            with pytest.raises(NotImplementedError, match="AsyncSqliteSaver"):
+                await saver.aget_tuple(self.config_1)
+            with pytest.raises(NotImplementedError, match="AsyncSqliteSaver"):
+                async for _ in saver.alist(self.config_1):
+                    pass
+
+    def test_metadata_predicate_sql_injection_prevention(self) -> None:
+        """Test that _metadata_predicate rejects malicious filter keys."""
+        # Test various SQL injection payloads
+        malicious_keys = [
+            "x') OR '1'='1",  # Boolean-based injection
+            "x') OR 1=1 --",  # Comment-based injection
+            "x') UNION SELECT 1,2,3,4,5,6,7 --",  # UNION-based injection
+            "access') = 'public' OR '1'='1' OR json_extract(value, '$.",  # Complex injection
+            "'; DROP TABLE checkpoints; --",  # Destructive injection
+        ]
+
+        for malicious_key in malicious_keys:
+            with pytest.raises(ValueError, match="Invalid filter key"):
+                _metadata_predicate({malicious_key: "dummy"})
+
+    def test_checkpoint_search_sql_injection_prevention(self) -> None:
+        """Test that SQL injection via malicious filter keys is prevented in checkpoint search."""
+        with SqliteSaver.from_conn_string(":memory:") as saver:
+            # Setup: Create checkpoints with different metadata
+            config_public: RunnableConfig = {
+                "configurable": {
+                    "thread_id": "thread-public",
+                    "checkpoint_ns": "",
+                }
+            }
+            config_private: RunnableConfig = {
+                "configurable": {
+                    "thread_id": "thread-private",
+                    "checkpoint_ns": "",
+                }
+            }
+
+            checkpoint_public = empty_checkpoint()
+            checkpoint_private = empty_checkpoint()
+
+            metadata_public: CheckpointMetadata = {
+                "access": "public",
+                "data": "public information",
+            }
+            metadata_private: CheckpointMetadata = {
+                "access": "private",
+                "data": "secret information",
+                "password": "secret123",
+            }
+
+            saver.put(config_public, checkpoint_public, metadata_public, {})
+            saver.put(config_private, checkpoint_private, metadata_private, {})
+
+            # Normal query - should return only public checkpoint
+            normal_results = list(saver.list(None, filter={"access": "public"}))
+            assert len(normal_results) == 1
+            assert normal_results[0].metadata["access"] == "public"
+
+            # SQL injection attempt should raise ValueError
+            malicious_key = (
+                "access') = 'public' OR '1'='1' OR json_extract(metadata, '$."
+            )
+
+            with pytest.raises(ValueError, match="Invalid filter key"):
+                list(saver.list(None, filter={malicious_key: "dummy"}))
+
+    def test_limit_parameter_sql_injection_prevention(self) -> None:
+        """Test that the limit parameter properly uses parameterized queries to prevent SQL injection."""
+        with SqliteSaver.from_conn_string(":memory:") as saver:
+            # Setup: Create multiple checkpoints
+            for i in range(5):
+                config: RunnableConfig = {
+                    "configurable": {
+                        "thread_id": f"thread-{i}",
+                        "checkpoint_ns": "",
+                    }
+                }
+                checkpoint = empty_checkpoint()
+                metadata: CheckpointMetadata = {"index": i}
+                saver.put(config, checkpoint, metadata, {})
+
+            # Test that limit works correctly with valid integer
+            results = list(saver.list(None, limit=2))
+            assert len(results) == 2
+
+            # Test that limit=0 returns no results
+            results = list(saver.list(None, limit=0))
+            assert len(results) == 0
+
+            # Test that limit=None returns all results
+            results = list(saver.list(None, limit=None))
+            assert len(results) == 5
+
+    def test_metadata_filter_keys_with_hyphens_and_digits(self) -> None:
+        """Metadata keys with hyphens and digit-start should be filterable.
+
+        This exposes incorrect JSON path handling (unquoted segments) by asserting
+        that such filters successfully match saved checkpoints.
+        """
+        with SqliteSaver.from_conn_string(":memory:") as saver:
+            config: RunnableConfig = {
+                "configurable": {
+                    "thread_id": "thread-hyphen-digit",
+                    "checkpoint_ns": "",
+                }
+            }
+            checkpoint = empty_checkpoint()
+            metadata: CheckpointMetadata = {
+                "access-level": "public",
+                "user": {"access-level": "nested", "123abc": "ok2"},
+                "123abc": "ok",
+            }
+            saver.put(config, checkpoint, metadata, {})
+
+            # Top-level hyphenated key
+            results = list(saver.list(None, filter={"access-level": "public"}))
+            assert len(results) == 1
+
+            # Nested hyphenated key via dotted path
+            results = list(saver.list(None, filter={"user.access-level": "nested"}))
+            assert len(results) == 1
+
+            # Top-level digit-starting key
+            results = list(saver.list(None, filter={"123abc": "ok"}))
+            assert len(results) == 1
+
+            # Nested digit-starting key via dotted path
+            results = list(saver.list(None, filter={"user.123abc": "ok2"}))
+            assert len(results) == 1

libs/checkpoint-sqlite/tests/test_ttl.py

@@ -0,0 +1,429 @@
+"""Test SQLite store Time-To-Live (TTL) functionality."""
+
+import asyncio
+import os
+import tempfile
+import time
+from collections.abc import Generator
+
+import pytest
+from langgraph.store.base import TTLConfig
+
+from langgraph.store.sqlite import SqliteStore
+from langgraph.store.sqlite.aio import AsyncSqliteStore
+
+
+@pytest.fixture
+def temp_db_file() -> Generator[str, None, None]:
+    """Create a temporary database file for testing."""
+    fd, path = tempfile.mkstemp()
+    os.close(fd)
+    yield path
+    os.unlink(path)
+
+
+def test_ttl_basic(temp_db_file: str) -> None:
+    """Test basic TTL functionality with synchronous API."""
+    ttl_seconds = 1
+    ttl_minutes = ttl_seconds / 60
+
+    with SqliteStore.from_conn_string(
+        temp_db_file, ttl={"default_ttl": ttl_minutes}
+    ) as store:
+        store.setup()
+
+        store.put(("test",), "item1", {"value": "test"})
+
+        item = store.get(("test",), "item1")
+        assert item is not None
+        assert item.value["value"] == "test"
+
+        time.sleep(ttl_seconds + 1.0)
+
+        store.sweep_ttl()
+
+        item = store.get(("test",), "item1")
+        assert item is None
+
+
+@pytest.mark.flaky(retries=3)
+def test_ttl_refresh(temp_db_file: str) -> None:
+    """Test TTL refresh on read."""
+    ttl_seconds = 1
+    ttl_minutes = ttl_seconds / 60
+
+    with SqliteStore.from_conn_string(
+        temp_db_file, ttl={"default_ttl": ttl_minutes, "refresh_on_read": True}
+    ) as store:
+        store.setup()
+
+        # Store an item with TTL
+        store.put(("test",), "item1", {"value": "test"})
+
+        # Sleep almost to expiration
+        time.sleep(ttl_seconds - 0.5)
+        swept = store.sweep_ttl()
+        assert swept == 0
+
+        # Get the item and refresh TTL
+        item = store.get(("test",), "item1", refresh_ttl=True)
+        assert item is not None
+
+        time.sleep(ttl_seconds - 0.5)
+        swept = store.sweep_ttl()
+        assert swept == 0
+
+        # Get the item, should still be there
+        item = store.get(("test",), "item1")
+        assert item is not None
+        assert item.value["value"] == "test"
+
+        # Sleep again but don't refresh this time
+        time.sleep(ttl_seconds + 0.75)
+
+        swept = store.sweep_ttl()
+        assert swept == 1
+
+        # Item should be gone now
+        item = store.get(("test",), "item1")
+        assert item is None
+
+
+def test_ttl_sweeper(temp_db_file: str) -> None:
+    """Test TTL sweeper thread."""
+    ttl_seconds = 2
+    ttl_minutes = ttl_seconds / 60
+
+    ttl_config: TTLConfig = {
+        "default_ttl": ttl_minutes,
+        "sweep_interval_minutes": ttl_minutes / 2,
+    }
+    with SqliteStore.from_conn_string(
+        temp_db_file,
+        ttl=ttl_config,
+    ) as store:
+        store.setup()
+
+        # Start the TTL sweeper
+        store.start_ttl_sweeper()
+
+        # Store an item with TTL
+        store.put(("test",), "item1", {"value": "test"})
+
+        # Item should be there initially
+        item = store.get(("test",), "item1")
+        assert item is not None
+
+        # Wait for TTL to expire and the sweeper to run
+        time.sleep(ttl_seconds + (ttl_seconds / 2) + 0.5)
+
+        # Item should be gone now (swept automatically)
+        item = store.get(("test",), "item1")
+        assert item is None
+
+        # Stop the sweeper
+        store.stop_ttl_sweeper()
+
+
+@pytest.mark.flaky(retries=3)
+def test_ttl_custom_value(temp_db_file: str) -> None:
+    """Test TTL with custom value per item."""
+    with SqliteStore.from_conn_string(temp_db_file) as store:
+        store.setup()
+
+        # Store items with different TTLs
+        store.put(("test",), "item1", {"value": "short"}, ttl=1 / 60)  # 1 second
+        store.put(("test",), "item2", {"value": "long"}, ttl=3 / 60)  # 3 seconds
+
+        # Item with short TTL
+        time.sleep(2)  # Wait for short TTL
+        store.sweep_ttl()
+
+        # Short TTL item should be gone, long TTL item should remain
+        item1 = store.get(("test",), "item1")
+        item2 = store.get(("test",), "item2")
+        assert item1 is None
+        assert item2 is not None
+
+        # Wait for the second item's TTL
+        time.sleep(4)
+        store.sweep_ttl()
+
+        # Now both should be gone
+        item2 = store.get(("test",), "item2")
+        assert item2 is None
+
+
+@pytest.mark.flaky(retries=3)
+def test_ttl_override_default(temp_db_file: str) -> None:
+    """Test overriding default TTL at the item level."""
+    with SqliteStore.from_conn_string(
+        temp_db_file,
+        ttl={"default_ttl": 5 / 60},  # 5 seconds default
+    ) as store:
+        store.setup()
+
+        # Store an item with shorter than default TTL
+        store.put(("test",), "item1", {"value": "override"}, ttl=1 / 60)  # 1 second
+
+        # Store an item with default TTL
+        store.put(("test",), "item2", {"value": "default"})  # Uses default 5 seconds
+
+        # Store an item with no TTL
+        store.put(("test",), "item3", {"value": "permanent"}, ttl=None)
+
+        # Wait for the override TTL to expire
+        time.sleep(2)
+        store.sweep_ttl()
+
+        # Check results
+        item1 = store.get(("test",), "item1")
+        item2 = store.get(("test",), "item2")
+        item3 = store.get(("test",), "item3")
+
+        assert item1 is None  # Should be expired
+        assert item2 is not None  # Default TTL, should still be there
+        assert item3 is not None  # No TTL, should still be there
+
+        # Wait for default TTL to expire
+        time.sleep(4)
+        store.sweep_ttl()
+
+        # Check results again
+        item2 = store.get(("test",), "item2")
+        item3 = store.get(("test",), "item3")
+
+        assert item2 is None  # Default TTL item should be gone
+        assert item3 is not None  # No TTL item should still be there
+
+
+@pytest.mark.flaky(retries=3)
+def test_search_with_ttl(temp_db_file: str) -> None:
+    """Test TTL with search operations."""
+    ttl_seconds = 1
+    ttl_minutes = ttl_seconds / 60
+
+    with SqliteStore.from_conn_string(
+        temp_db_file, ttl={"default_ttl": ttl_minutes}
+    ) as store:
+        store.setup()
+
+        # Store items
+        store.put(("test",), "item1", {"value": "apple"})
+        store.put(("test",), "item2", {"value": "banana"})
+
+        # Search before expiration
+        results = store.search(("test",), filter={"value": "apple"})
+        assert len(results) == 1
+        assert results[0].key == "item1"
+
+        # Wait for TTL to expire
+        time.sleep(ttl_seconds + 1)
+        store.sweep_ttl()
+
+        # Search after expiration
+        results = store.search(("test",), filter={"value": "apple"})
+        assert len(results) == 0
+
+
+@pytest.mark.asyncio
+async def test_async_ttl_basic(temp_db_file: str) -> None:
+    """Test basic TTL functionality with asynchronous API."""
+    ttl_seconds = 1
+    ttl_minutes = ttl_seconds / 60
+
+    async with AsyncSqliteStore.from_conn_string(
+        temp_db_file, ttl={"default_ttl": ttl_minutes}
+    ) as store:
+        await store.setup()
+
+        # Store an item with TTL
+        await store.aput(("test",), "item1", {"value": "test"})
+
+        # Get the item before expiration
+        item = await store.aget(("test",), "item1")
+        assert item is not None
+        assert item.value["value"] == "test"
+
+        # Wait for TTL to expire
+        await asyncio.sleep(ttl_seconds + 1.0)
+
+        # Manual sweep needed without the sweeper thread
+        await store.sweep_ttl()
+
+        # Item should be gone now
+        item = await store.aget(("test",), "item1")
+        assert item is None
+
+
+@pytest.mark.asyncio
+@pytest.mark.flaky(retries=3)
+async def test_async_ttl_refresh(temp_db_file: str) -> None:
+    """Test TTL refresh on read with async API."""
+    ttl_seconds = 1
+    ttl_minutes = ttl_seconds / 60
+
+    async with AsyncSqliteStore.from_conn_string(
+        temp_db_file, ttl={"default_ttl": ttl_minutes, "refresh_on_read": True}
+    ) as store:
+        await store.setup()
+
+        # Store an item with TTL
+        await store.aput(("test",), "item1", {"value": "test"})
+
+        # Sleep almost to expiration
+        await asyncio.sleep(ttl_seconds - 0.5)
+
+        # Get the item and refresh TTL
+        item = await store.aget(("test",), "item1", refresh_ttl=True)
+        assert item is not None
+
+        # Sleep again - without refresh, would have expired by now
+        await asyncio.sleep(ttl_seconds - 0.5)
+
+        # Get the item, should still be there
+        item = await store.aget(("test",), "item1")
+        assert item is not None
+        assert item.value["value"] == "test"
+
+        # Sleep again but don't refresh this time
+        await asyncio.sleep(ttl_seconds + 1.0)
+
+        # Manual sweep
+        await store.sweep_ttl()
+
+        # Item should be gone now
+        item = await store.aget(("test",), "item1")
+        assert item is None
+
+
+@pytest.mark.asyncio
+async def test_async_ttl_sweeper(temp_db_file: str) -> None:
+    """Test TTL sweeper thread with async API."""
+    ttl_seconds = 2
+    ttl_minutes = ttl_seconds / 60
+
+    ttl_config: TTLConfig = {
+        "default_ttl": ttl_minutes,
+        "sweep_interval_minutes": ttl_minutes / 2,
+    }
+
+    async with AsyncSqliteStore.from_conn_string(
+        temp_db_file,
+        ttl=ttl_config,
+    ) as store:
+        await store.setup()
+
+        # Start the TTL sweeper
+        await store.start_ttl_sweeper()
+
+        # Store an item with TTL
+        await store.aput(("test",), "item1", {"value": "test"})
+
+        # Item should be there initially
+        item = await store.aget(("test",), "item1")
+        assert item is not None
+
+        # Wait for TTL to expire and the sweeper to run
+        await asyncio.sleep(ttl_seconds + (ttl_seconds / 2) + 0.5)
+
+        # Item should be gone now (swept automatically)
+        item = await store.aget(("test",), "item1")
+        assert item is None
+
+        # Stop the sweeper
+        await store.stop_ttl_sweeper()
+
+
+@pytest.mark.asyncio
+@pytest.mark.flaky(retries=3)
+async def test_async_search_with_ttl(temp_db_file: str) -> None:
+    """Test TTL with search operations using async API."""
+    ttl_seconds = 1
+    ttl_minutes = ttl_seconds / 60
+
+    async with AsyncSqliteStore.from_conn_string(
+        temp_db_file, ttl={"default_ttl": ttl_minutes}
+    ) as store:
+        await store.setup()
+
+        # Store items
+        await store.aput(("test",), "item1", {"value": "apple"})
+        await store.aput(("test",), "item2", {"value": "banana"})
+
+        # Search before expiration
+        results = await store.asearch(("test",), filter={"value": "apple"})
+        assert len(results) == 1
+        assert results[0].key == "item1"
+
+        # Wait for TTL to expire
+        await asyncio.sleep(ttl_seconds + 1)
+        await store.sweep_ttl()
+
+        # Search after expiration
+        results = await store.asearch(("test",), filter={"value": "apple"})
+        assert len(results) == 0
+
+
+@pytest.mark.asyncio
+@pytest.mark.flaky(retries=3)
+async def test_async_asearch_refresh_ttl(temp_db_file: str) -> None:
+    """Test TTL refresh on asearch with async API."""
+    ttl_seconds = 4.0  # Increased TTL for less sensitivity to timing
+    ttl_minutes = ttl_seconds / 60.0
+
+    async with AsyncSqliteStore.from_conn_string(
+        temp_db_file, ttl={"default_ttl": ttl_minutes, "refresh_on_read": True}
+    ) as store:
+        await store.setup()
+
+        namespace = ("docs", "user1")
+        # t=0: items put, expire at t=4.0s
+        await store.aput(namespace, "item1", {"text": "content1", "id": 1})
+        await store.aput(namespace, "item2", {"text": "content2", "id": 2})
+
+        # t=3.0s: (after sleep ttl_seconds * 0.75 = 3s)
+        await asyncio.sleep(ttl_seconds * 0.75)
+
+        # Perform asearch with refresh_ttl=True for item1.
+        # item1's TTL should be refreshed. New expiry: t=3.0s + 4.0s = t=7.0s.
+        # item2's TTL is not affected. Expires at t=4.0s.
+        searched_items = await store.asearch(
+            namespace, filter={"id": 1}, refresh_ttl=True
+        )
+        assert len(searched_items) == 1
+        assert searched_items[0].key == "item1"
+
+        # t=5.0s: (after sleep ttl_seconds * 0.5 = 2s more. Total elapsed: 3s + 2s = 5s)
+        await asyncio.sleep(ttl_seconds * 0.5)
+        # At this point:
+        # - item1 (refreshed by asearch) should expire at t=7.0s. Should be ALIVE.
+        # - item2 (original TTL) should have expired at t=4.0s. Should be GONE after sweep.
+
+        await store.sweep_ttl()
+
+        # Check item1 (should exist due to asearch refresh)
+        item1_check1 = await store.aget(namespace, "item1", refresh_ttl=False)
+        assert item1_check1 is not None, (
+            "Item1 should exist after asearch refresh and first sweep"
+        )
+        assert item1_check1.value["text"] == "content1"
+
+        # Check item2 (should be gone)
+        item2_check1 = await store.aget(namespace, "item2", refresh_ttl=False)
+        assert item2_check1 is None, (
+            "Item2 should be gone after its original TTL expired"
+        )
+
+        # t=7.5s: (after sleep ttl_seconds * 0.625 = 2.5s more. Total elapsed: 5s + 2.5s = 7.5s)
+        await asyncio.sleep(ttl_seconds * 0.625)
+        # At this point:
+        # - item1 (refreshed by asearch, expired at t=7.0s) should be GONE after sweep.
+
+        await store.sweep_ttl()
+
+        # Check item1 again (should be gone now)
+        item1_final_check = await store.aget(namespace, "item1", refresh_ttl=False)
+        assert item1_final_check is None, (
+            "Item1 should be gone after its refreshed TTL expired"
+        )