langgraph-runtime-inmem 0.22.0__py3-none-any.whl → 0.23.0__py3-none-any.whl

langgraph_runtime_inmem/__init__.py

@@ -10,7 +10,7 @@ from langgraph_runtime_inmem import (
     store,
 )
 
-__version__ = "0.22.0"
+__version__ = "0.23.0"
 __all__ = [
     "ops",
     "database",

langgraph_runtime_inmem/_persistence.py

@@ -0,0 +1,58 @@
+"""Periodic flushing for all PersistentDict stores."""
+
+from __future__ import annotations
+
+import functools
+import logging
+import threading
+import weakref
+
+from langgraph.checkpoint.memory import PersistentDict
+
+logger = logging.getLogger(__name__)
+
+_stores: dict[str, weakref.ref[PersistentDict]] = {}
+_flush_thread: tuple[threading.Event, threading.Thread] | None = None
+_flush_interval: int = 10
+
+
+def register_persistent_dict(d: PersistentDict) -> None:
+    """Register a PersistentDict for periodic flushing."""
+    global _flush_thread
+    _stores[d.filename] = weakref.ref(d)
+    if _flush_thread is None:
+        logger.info("Starting dev persistence flush loop")
+        stop_event = threading.Event()
+        _flush_thread = (
+            stop_event,
+            threading.Thread(
+                target=functools.partial(_flush_loop, stop_event), daemon=True
+            ),
+        )
+        _flush_thread[1].start()
+
+
+def stop_flush_loop() -> None:
+    """Stop the background flush thread."""
+    global _flush_thread
+    if _flush_thread is not None:
+        logger.info("Stopping dev persistence flush loop")
+        _flush_thread[0].set()
+        _flush_thread[1].join()
+        _flush_thread = None
+
+
+def _flush_loop(stop_event: threading.Event) -> None:
+    drop = set()
+    while not stop_event.wait(timeout=_flush_interval):
+        keys = list(_stores.keys())
+        for store_key in keys:
+            if store := _stores[store_key]():
+                store.sync()
+            else:
+                drop.add(store_key)
+        if drop:
+            for store_key in drop:
+                del _stores[store_key]
+            drop.clear()
+    logger.info("dev persistence flush loop exiting")

langgraph_runtime_inmem/checkpoint.py

@@ -4,10 +4,21 @@ import logging
 import os
 import typing
 import uuid
-from collections.abc import AsyncIterator
+from collections import defaultdict
+from collections.abc import AsyncIterator, Callable
 from typing import Any
 
-from langgraph.checkpoint.memory import MemorySaver, PersistentDict
+from langgraph.checkpoint.memory import (
+    InMemorySaver as InMemorySaverBase,
+)
+from langgraph.checkpoint.memory import (
+    PersistentDict,
+)
+
+from langgraph_runtime_inmem._persistence import (
+    register_persistent_dict,
+    stop_flush_loop,
+)
 
 if typing.TYPE_CHECKING:
     from langchain_core.runnables import RunnableConfig
@@ -37,13 +48,15 @@ DISABLE_FILE_PERSISTENCE = (
 )
 
 
-class InMemorySaver(MemorySaver):
+class InMemorySaver(InMemorySaverBase):
     def __init__(
         self,
         *,
         serde: SerializerProtocol | None = None,
+        __persistence_hook__: Callable[[PersistentDict], None] | None = None,
     ) -> None:
         self.filename = os.path.join(".langgraph_api", ".langgraph_checkpoint.")
+        self.latest_iter: AsyncIterator[CheckpointTuple] | None = None
         i = 0
 
         def factory(*args):
@@ -54,6 +67,8 @@ class InMemorySaver(MemorySaver):
                 os.mkdir(".langgraph_api")
             thisfname = self.filename + str(i) + ".pckl"
             d = PersistentDict(*args, filename=thisfname)
+            if __persistence_hook__:
+                __persistence_hook__(d)
 
             try:
                 d.load()
@@ -84,7 +99,7 @@ class InMemorySaver(MemorySaver):
 
         super().__init__(
             serde=serde if serde is not None else Serializer(),
-            factory=factory if not DISABLE_FILE_PERSISTENCE else None,
+            factory=factory if not DISABLE_FILE_PERSISTENCE else defaultdict,
         )
 
     def put(
@@ -147,12 +162,10 @@ class InMemorySaver(MemorySaver):
 
         if not api_config.LANGGRAPH_ENCRYPTION:
             return data
-        from langgraph_api.api.encryption_middleware import decrypt_json_if_needed
-        from langgraph_api.encryption import get_encryption_instance
+        from langgraph_api.encryption import get_encryption
+        from langgraph_api.encryption.middleware import decrypt_json_if_needed
 
-        result = await decrypt_json_if_needed(
-            data, get_encryption_instance(), "checkpoint"
-        )
+        result = await decrypt_json_if_needed(data, get_encryption(), "checkpoint")
         if result is None:
             raise ValueError("decrypt_json_if_needed returned None for non-None input")
         return result
@@ -199,6 +212,15 @@ class InMemorySaver(MemorySaver):
                 pending_writes=tuple_.pending_writes,
             )
 
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        stop_flush_loop()
+        await super().__aexit__(exc_type, exc_val, exc_tb)
+
+    async def aget_iter(self, config: RunnableConfig) -> AsyncIterator[CheckpointTuple]:
+        tup = await self.aget_tuple(config)
+        if tup is not None:
+            yield tup
+
 
 MEMORY = None
 
@@ -206,12 +228,16 @@ MEMORY = None
 def Checkpointer(*args, unpack_hook=None, **kwargs):
     global MEMORY
     if MEMORY is None:
-        MEMORY = InMemorySaver()
+        MEMORY = InMemorySaver(
+            __persistence_hook__=register_persistent_dict,
+        )
     if unpack_hook is not None:
         from langgraph_api.serde import Serializer
 
         saver = InMemorySaver(
-            serde=Serializer(__unpack_ext_hook__=unpack_hook), **kwargs
+            serde=Serializer(__unpack_ext_hook__=unpack_hook),
+            __persistence_hook__=register_persistent_dict,
+            **kwargs,
         )
         saver.writes = MEMORY.writes
         saver.blobs = MEMORY.blobs

langgraph_runtime_inmem/database.py

@@ -13,6 +13,7 @@ from langgraph.checkpoint.memory import PersistentDict
 from typing_extensions import TypedDict
 
 from langgraph_runtime_inmem import store
+from langgraph_runtime_inmem._persistence import register_persistent_dict
 from langgraph_runtime_inmem.inmem_stream import start_stream, stop_stream
 
 if TYPE_CHECKING:
@@ -114,6 +115,10 @@ class InMemoryRetryCounter:
 GLOBAL_RETRY_COUNTER = InMemoryRetryCounter()
 GLOBAL_STORE = GlobalStore(filename=OPS_FILENAME)
 
+# Register for periodic flushing
+register_persistent_dict(GLOBAL_STORE)
+register_persistent_dict(GLOBAL_RETRY_COUNTER._counters)
+
 
 class InMemConnectionProto:
     def __init__(self):

langgraph_runtime_inmem/lifespan.py

@@ -30,6 +30,9 @@ async def lifespan(
 ):
     import langgraph_api.config as config
     from langgraph_api import __version__, feature_flags, graph, thread_ttl
+    from langgraph_api import (
+        _checkpointer as api_checkpointer,
+    )
     from langgraph_api import store as api_store
     from langgraph_api.asyncio import SimpleTaskGroup, set_event_loop
     from langgraph_api.http import start_http_client, stop_http_client
@@ -54,6 +57,7 @@ async def lifespan(
 
     await start_http_client()
     await start_pool()
+    await api_checkpointer.start_checkpointer()
     await start_ui_bundler()
 
     async def _log_graph_load_failure(err: graph.GraphLoadError) -> None:
@@ -119,6 +123,7 @@ async def lifespan(
         pass
     finally:
         await api_store.exit_store()
+        await api_checkpointer.exit_checkpointer()
         await stop_ui_bundler()
         await graph.stop_remote_graphs()
         await stop_http_client()

langgraph_runtime_inmem/ops.py

@@ -10,7 +10,7 @@ import typing
 import uuid
 from collections import defaultdict
 from collections.abc import AsyncIterator, Sequence
-from contextlib import asynccontextmanager
+from contextlib import AsyncExitStack, asynccontextmanager
 from datetime import UTC, datetime, timedelta
 from typing import Any, Literal, cast
 from uuid import UUID, uuid4
@@ -150,6 +150,8 @@ class Assistants(Authenticated):
         select: list[AssistantSelectField] | None = None,
         ctx: Auth.types.BaseAuthContext | None = None,
     ) -> tuple[AsyncIterator[Assistant], int]:
+        from langgraph_api.graph import assert_graph_exists
+
         metadata = metadata if metadata is not None else {}
         filters = await Assistants.handle_event(
             ctx,
@@ -159,6 +161,9 @@ class Assistants(Authenticated):
             ),
         )
 
+        if graph_id is not None:
+            assert_graph_exists(graph_id)
+
         # Get all assistants and filter them
         assistants = conn.store["assistants"]
         filtered_assistants = [
@@ -250,7 +255,7 @@ class Assistants(Authenticated):
         description: str | None = None,
     ) -> AsyncIterator[Assistant]:
         """Insert an assistant."""
-        from langgraph_api.graph import GRAPHS
+        from langgraph_api.graph import assert_graph_exists
 
         assistant_id = _ensure_uuid(assistant_id)
         metadata = metadata if metadata is not None else {}
@@ -273,8 +278,7 @@ class Assistants(Authenticated):
                 detail="Cannot specify both configurable and context. Prefer setting context alone. Context was introduced in LangGraph 0.6.0 and is the long term planned replacement for configurable.",
             )
 
-        if graph_id not in GRAPHS:
-            raise HTTPException(status_code=404, detail=f"Graph {graph_id} not found")
+        assert_graph_exists(graph_id)
 
         # Keep config and context up to date with one another
         if config.get("configurable"):
@@ -365,6 +369,8 @@ class Assistants(Authenticated):
         Returns:
             return the updated assistant model.
         """
+        from langgraph_api.graph import assert_graph_exists
+
         assistant_id = _ensure_uuid(assistant_id)
         metadata = metadata if metadata is not None else {}
         config = config if config is not None else {}
@@ -387,6 +393,9 @@ class Assistants(Authenticated):
                 detail="Cannot specify both configurable and context. Prefer setting context alone. Context was introduced in LangGraph 0.6.0 and is the long term planned replacement for configurable.",
             )
 
+        if graph_id is not None:
+            assert_graph_exists(graph_id)
+
         # Keep config and context up to date with one another
         if config.get("configurable"):
             context = config["configurable"]
@@ -462,55 +471,85 @@ class Assistants(Authenticated):
 
     @staticmethod
     async def delete(
-        conn: InMemConnectionProto,
+        conn: InMemConnectionProto | None,
         assistant_id: UUID,
         ctx: Auth.types.BaseAuthContext | None = None,
+        *,
+        delete_threads: bool = False,
     ) -> AsyncIterator[UUID]:
         """Delete an assistant by ID."""
-        assistant_id = _ensure_uuid(assistant_id)
-        filters = await Assistants.handle_event(
-            ctx,
-            "delete",
-            Auth.types.AssistantsDelete(
-                assistant_id=assistant_id,
-            ),
-        )
-        assistant = next(
-            (a for a in conn.store["assistants"] if a["assistant_id"] == assistant_id),
-            None,
-        )
+        async with AsyncExitStack() as stack:
+            if conn is None:
+                conn = await stack.enter_async_context(connect())
 
-        if not assistant:
-            raise HTTPException(
-                status_code=404, detail=f"Assistant with ID {assistant_id} not found"
+            assistant_id = _ensure_uuid(assistant_id)
+            filters = await Assistants.handle_event(
+                ctx,
+                "delete",
+                Auth.types.AssistantsDelete(
+                    assistant_id=assistant_id,
+                ),
             )
-        elif filters and not _check_filter_match(assistant["metadata"], filters):
-            raise HTTPException(
-                status_code=404, detail=f"Assistant with ID {assistant_id} not found"
+            assistant = next(
+                (
+                    a
+                    for a in conn.store["assistants"]
+                    if a["assistant_id"] == assistant_id
+                ),
+                None,
             )
 
-        # Cancel all in-flight runs for this assistant before deletion
-        await Runs.cancel(
-            conn,
-            assistant_id=assistant_id,
-            action="interrupt",
-            ctx=ctx,
-        )
+            if not assistant:
+                raise HTTPException(
+                    status_code=404,
+                    detail=f"Assistant with ID {assistant_id} not found",
+                )
+            elif filters and not _check_filter_match(assistant["metadata"], filters):
+                raise HTTPException(
+                    status_code=404,
+                    detail=f"Assistant with ID {assistant_id} not found",
+                )
 
-        conn.store["assistants"] = [
-            a for a in conn.store["assistants"] if a["assistant_id"] != assistant_id
-        ]
-        # Cascade delete assistant versions
-        conn.store["assistant_versions"] = [
-            v
-            for v in conn.store["assistant_versions"]
-            if v["assistant_id"] != assistant_id
-        ]
+            if delete_threads:
+                threads_to_delete = [
+                    t["thread_id"]
+                    for t in conn.store["threads"]
+                    if t.get("metadata", {}).get("assistant_id") == str(assistant_id)
+                ]
+                for thread_id in threads_to_delete:
+                    try:
+                        async for _ in await Threads.delete(conn, thread_id, ctx=ctx):
+                            pass
+                    except HTTPException:
+                        await logger.awarning(
+                            "Skipping thread deletion during cascade delete (user lacks permission)",
+                            thread_id=thread_id,
+                            assistant_id=assistant_id,
+                        )
 
-        async def _yield_deleted():
-            yield assistant_id
+            # 3. Cancel in-flight runs AFTER auth validation
+            await Runs.cancel(
+                conn,
+                assistant_id=assistant_id,
+                action="interrupt",
+                ctx=ctx,
+            )
 
-        return _yield_deleted()
+            # 4. Delete assistant
+            conn.store["assistants"] = [
+                a for a in conn.store["assistants"] if a["assistant_id"] != assistant_id
+            ]
+            # Cascade delete assistant versions
+            conn.store["assistant_versions"] = [
+                v
+                for v in conn.store["assistant_versions"]
+                if v["assistant_id"] != assistant_id
+            ]
+
+            async def _yield_deleted():
+                yield assistant_id
+
+            return _yield_deleted()
 
     @staticmethod
     async def set_latest(
@@ -632,6 +671,8 @@ class Assistants(Authenticated):
         ctx: Auth.types.BaseAuthContext | None = None,
     ) -> int:
         """Get count of assistants."""
+        from langgraph_api.graph import assert_graph_exists
+
         metadata = metadata if metadata is not None else {}
         filters = await Assistants.handle_event(
             ctx,
@@ -641,6 +682,9 @@ class Assistants(Authenticated):
             ),
         )
 
+        if graph_id is not None:
+            assert_graph_exists(graph_id)
+
         count = 0
         for assistant in conn.store["assistants"]:
             if (

langgraph_runtime_inmem/store.py

@@ -10,6 +10,8 @@ from langgraph.store.base import BaseStore, Op, Result
 from langgraph.store.base.batch import AsyncBatchedBaseStore
 from langgraph.store.memory import InMemoryStore
 
+from langgraph_runtime_inmem._persistence import register_persistent_dict
+
 _STORE_CONFIG = None
 DISABLE_FILE_PERSISTENCE = (
     os.getenv("LANGGRAPH_DISABLE_FILE_PERSISTENCE", "false").lower() == "true"
@@ -24,6 +26,8 @@ class DiskBackedInMemStore(InMemoryStore):
             self._vectors = PersistentDict(
                 lambda: defaultdict(dict), filename=_VECTOR_FILE
             )
+            register_persistent_dict(self._data)
+            register_persistent_dict(self._vectors)
         else:
             self._data = InMemoryStore._data
             self._vectors = InMemoryStore._vectors

{langgraph_runtime_inmem-0.22.0.dist-info → langgraph_runtime_inmem-0.23.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-runtime-inmem
-Version: 0.22.0
+Version: 0.23.0
 Summary: Inmem implementation for the LangGraph API server.
 Author-email: Will Fu-Hinthorn <will@langchain.dev>
 License: Elastic-2.0

langgraph_runtime_inmem-0.23.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+langgraph_runtime_inmem/__init__.py,sha256=oKfMmvvPRewTlo9oduB3tCC3l2b2MiD_9lka4PMm_5M,337
+langgraph_runtime_inmem/_persistence.py,sha256=exchMr_NQB_h7PHt0vq5QBh25cOGoW0jHAFo07b1BFI,1711
+langgraph_runtime_inmem/checkpoint.py,sha256=VD5c6CktsToo_f4qPe1WP_csdonQoOb7h5lHv4U0ZAE,8372
+langgraph_runtime_inmem/database.py,sha256=iP7W1SI4kUkqcHtkg3aMmP-YLgZfvMHANwN-P4Pb1pY,6607
+langgraph_runtime_inmem/inmem_stream.py,sha256=PFLWbsxU8RqbT5mYJgNk6v5q6TWJRIY1hkZWhJF8nkI,9094
+langgraph_runtime_inmem/lifespan.py,sha256=51w3ZKvxcosd7XKkTE2Tnxtr3tux4rJuChGEN0CuvCY,4935
+langgraph_runtime_inmem/metrics.py,sha256=_YiSkLnhQvHpMktk38SZo0abyL-5GihfVAtBo0-lFIc,403
+langgraph_runtime_inmem/ops.py,sha256=OZ1VicFoh9eOxD15LbZsmCZ1JTaWkMUjdY0nF0t9e-k,120806
+langgraph_runtime_inmem/queue.py,sha256=WM6ZJu25QPVjFXeJYW06GALLUgRsnRrA4YdypR0oG0U,9584
+langgraph_runtime_inmem/retry.py,sha256=XmldOP4e_H5s264CagJRVnQMDFcEJR_dldVR1Hm5XvM,763
+langgraph_runtime_inmem/routes.py,sha256=VVNxgJ8FWI3kDBoIgQUWN1gY5ivo7L954Agxzv72TAY,1377
+langgraph_runtime_inmem/store.py,sha256=a3YKsLnFv4bu3zPvagIFv0xmtrIp_pmGvj1CnD3PHL0,3682
+langgraph_runtime_inmem-0.23.0.dist-info/METADATA,sha256=9x1G8RrISXklr1MikxsE4kJFZTswjmATqNgA0EsPQYY,570
+langgraph_runtime_inmem-0.23.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+langgraph_runtime_inmem-0.23.0.dist-info/RECORD,,

langgraph_runtime_inmem-0.22.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-langgraph_runtime_inmem/__init__.py,sha256=MEt3B-cz2OdptjyXn7hgqdFgWBMBLaSY3wsKSEeB8Cg,337
-langgraph_runtime_inmem/checkpoint.py,sha256=lFUjSGra3xqD39FY3U-PgxYMXU6j1L28WPajmXT7-YE,7478
-langgraph_runtime_inmem/database.py,sha256=g2XYa5KN-T8MbDeFH9sfUApDG62Wp4BACumVnDtxYhI,6403
-langgraph_runtime_inmem/inmem_stream.py,sha256=PFLWbsxU8RqbT5mYJgNk6v5q6TWJRIY1hkZWhJF8nkI,9094
-langgraph_runtime_inmem/lifespan.py,sha256=fCoYcN_h0cxmj6-muC-f0csPdSpyepZuGRD1yBrq4XM,4755
-langgraph_runtime_inmem/metrics.py,sha256=_YiSkLnhQvHpMktk38SZo0abyL-5GihfVAtBo0-lFIc,403
-langgraph_runtime_inmem/ops.py,sha256=qJaQb138aL9D8ROy4yRaxlcaCuiNfoSDIX7m6lCWndE,119178
-langgraph_runtime_inmem/queue.py,sha256=WM6ZJu25QPVjFXeJYW06GALLUgRsnRrA4YdypR0oG0U,9584
-langgraph_runtime_inmem/retry.py,sha256=XmldOP4e_H5s264CagJRVnQMDFcEJR_dldVR1Hm5XvM,763
-langgraph_runtime_inmem/routes.py,sha256=VVNxgJ8FWI3kDBoIgQUWN1gY5ivo7L954Agxzv72TAY,1377
-langgraph_runtime_inmem/store.py,sha256=rTfL1JJvd-j4xjTrL8qDcynaWF6gUJ9-GDVwH0NBD_I,3506
-langgraph_runtime_inmem-0.22.0.dist-info/METADATA,sha256=viwco9HtZ2XtqNpn1nnBoLT2r2_8fvT8tqO3s2LwjHo,570
-langgraph_runtime_inmem-0.22.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-langgraph_runtime_inmem-0.22.0.dist-info/RECORD,,