langgraph-runtime-inmem 0.20.1__py3-none-any.whl → 0.21.0__py3-none-any.whl

langgraph_runtime_inmem/__init__.py

@@ -9,7 +9,7 @@ from langgraph_runtime_inmem import (
     store,
 )
 
-__version__ = "0.20.1"
+__version__ = "0.21.0"
 __all__ = [
     "ops",
     "database",

langgraph_runtime_inmem/checkpoint.py

@@ -4,6 +4,8 @@ import logging
 import os
 import typing
 import uuid
+from collections.abc import AsyncIterator
+from typing import Any
 
 from langgraph.checkpoint.memory import MemorySaver, PersistentDict
 
@@ -116,6 +118,64 @@ class InMemorySaver(MemorySaver):
             if os.path.exists(file_path):
                 os.remove(file_path)
 
+    async def _decrypt_json(self, data: dict[str, Any]) -> dict[str, Any]:
+        """Decrypt a dict if custom encryption is configured."""
+        from langgraph_api import config as api_config
+
+        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
+
+        result = await decrypt_json_if_needed(
+            data, get_encryption_instance(), "checkpoint"
+        )
+        if result is None:
+            raise ValueError("decrypt_json_if_needed returned None for non-None input")
+        return result
+
+    async def aget_tuple(self, config: RunnableConfig) -> CheckpointTuple | None:
+        """Get checkpoint tuple with decrypted metadata."""
+        tuple_ = self.get_tuple(config)
+        if tuple_ is None:
+            return None
+
+        # Decrypt metadata if encryption is enabled
+        decrypted_metadata = await self._decrypt_json(tuple_.metadata)
+
+        from langgraph.checkpoint.base import CheckpointTuple as CPTuple
+
+        return CPTuple(
+            config=tuple_.config,
+            checkpoint=tuple_.checkpoint,
+            metadata=decrypted_metadata,
+            parent_config=tuple_.parent_config,
+            pending_writes=tuple_.pending_writes,
+        )
+
+    async def alist(
+        self,
+        config: RunnableConfig | None,
+        *,
+        filter: dict[str, Any] | None = None,
+        before: RunnableConfig | None = None,
+        limit: int | None = None,
+    ) -> AsyncIterator[CheckpointTuple]:
+        """List checkpoints with decrypted metadata."""
+        from langgraph.checkpoint.base import CheckpointTuple as CPTuple
+
+        for tuple_ in self.list(config, filter=filter, before=before, limit=limit):
+            # Decrypt metadata if encryption is enabled
+            decrypted_metadata = await self._decrypt_json(tuple_.metadata)
+
+            yield CPTuple(
+                config=tuple_.config,
+                checkpoint=tuple_.checkpoint,
+                metadata=decrypted_metadata,
+                parent_config=tuple_.parent_config,
+                pending_writes=tuple_.pending_writes,
+            )
+
 
 MEMORY = None
 

langgraph_runtime_inmem/ops.py

@@ -489,24 +489,23 @@ class Assistants(Authenticated):
                 status_code=404, detail=f"Assistant with ID {assistant_id} not found"
             )
 
+        # Cancel all in-flight runs for this assistant before deletion
+        await Runs.cancel(
+            conn,
+            assistant_id=assistant_id,
+            action="interrupt",
+            ctx=ctx,
+        )
+
         conn.store["assistants"] = [
             a for a in conn.store["assistants"] if a["assistant_id"] != assistant_id
         ]
-        # Cascade delete assistant versions, crons, & runs on this assistant
+        # Cascade delete assistant versions
         conn.store["assistant_versions"] = [
             v
             for v in conn.store["assistant_versions"]
             if v["assistant_id"] != assistant_id
         ]
-        retained = []
-        for run in conn.store["runs"]:
-            if run["assistant_id"] == assistant_id:
-                res = await Runs.delete(
-                    conn, run["run_id"], thread_id=run["thread_id"], ctx=ctx
-                )
-                await anext(res)
-            else:
-                retained.append(run)
 
         async def _yield_deleted():
             yield assistant_id
@@ -883,8 +882,16 @@ class Threads(Authenticated):
         conn: InMemConnectionProto,
         thread_id: UUID,
         ctx: Auth.types.BaseAuthContext | None = None,
+        include_ttl: bool = False,
     ) -> AsyncIterator[Thread]:
-        """Get a thread by ID."""
+        """Get a thread by ID.
+
+        Args:
+            conn: In-memory connection
+            thread_id: Thread ID
+            ctx: Auth context
+            include_ttl: Not supported in inmem - parameter ignored.
+        """
         matching_thread = await Threads._get(conn, thread_id, ctx)
 
         if not matching_thread:
@@ -1222,6 +1229,48 @@ class Threads(Authenticated):
 
         return empty_iterator()
 
+    @staticmethod
+    async def prune(
+        thread_ids: Sequence[str] | Sequence[UUID],
+        strategy: Literal["delete", "keep_latest"] = "delete",
+        batch_size: int = 100,
+        ctx: Auth.types.BaseAuthContext | None = None,
+    ) -> int:
+        """Prune threads by ID (inmem implementation).
+
+        Args:
+            thread_ids: List of thread IDs to prune
+            strategy: Prune strategy ("delete" supported, "keep_latest" not supported)
+            batch_size: Not used in inmem implementation
+            ctx: Auth context for permission checks
+
+        Returns:
+            Number of threads successfully pruned
+        """
+        if not thread_ids:
+            return 0
+
+        if strategy == "keep_latest":
+            raise HTTPException(
+                status_code=422,
+                detail="keep_latest strategy is not supported in in-memory runtime",
+            )
+
+        pruned = 0
+        async with connect() as conn:
+            for tid in thread_ids:
+                try:
+                    tid_uuid = _ensure_uuid(tid)
+                    iter_result = await Threads.delete(conn, tid_uuid, ctx)
+                    # Consume the iterator to ensure deletion
+                    async for _ in iter_result:
+                        pruned += 1
+                except HTTPException:
+                    # Thread not found or no permission - skip silently
+                    pass
+
+        return pruned
+
     @staticmethod
     async def _delete_with_run(
         conn: InMemConnectionProto,
@@ -1981,6 +2030,7 @@ class Runs(Authenticated):
                 "n_pending": 0,
                 "pending_runs_wait_time_max_secs": None,
                 "pending_runs_wait_time_med_secs": None,
+                "pending_unblocked_runs_wait_time_max_secs": None,
                 "n_running": 0,
             }
 
@@ -2005,11 +2055,34 @@ class Runs(Authenticated):
         else:
             med_pending_wait = None
 
+        # Calculate max wait time for unblocked runs (runs not blocked by another run on the same thread)
+        pending_unblocked_waits: list[float] = []
+        for run in pending_runs:
+            thread_id = run.get("thread_id")
+            # Check if there's a running run on the same thread
+            has_running_on_thread = any(
+                r.get("thread_id") == thread_id and r.get("status") == "running"
+                for r in conn.store["runs"]
+            )
+            if not has_running_on_thread:
+                created_at = run.get("created_at")
+                if not isinstance(created_at, datetime):
+                    continue
+                if created_at.tzinfo is None:
+                    created_at = created_at.replace(tzinfo=UTC)
+                if created_at < now:
+                    pending_unblocked_waits.append((now - created_at).total_seconds())
+
+        max_unblocked_wait = (
+            max(pending_unblocked_waits) if pending_unblocked_waits else None
+        )
+
         return {
             "n_pending": len(pending_runs),
             "n_running": len(running_runs),
             "pending_runs_wait_time_max_secs": max_pending_wait,
             "pending_runs_wait_time_med_secs": med_pending_wait,
+            "pending_unblocked_runs_wait_time_max_secs": max_unblocked_wait,
         }
 
     @staticmethod
@@ -2410,12 +2483,14 @@ class Runs(Authenticated):
         action: Literal["interrupt", "rollback"] = "interrupt",
         thread_id: UUID | None = None,
         status: Literal["pending", "running", "all"] | None = None,
+        assistant_id: UUID | None = None,
         ctx: Auth.types.BaseAuthContext | None = None,
     ) -> None:
         """
         Cancel runs in memory. Must provide either:
         1) thread_id + run_ids, or
-        2) status in {"pending", "running", "all"}.
+        2) status in {"pending", "running", "all"}, or
+        3) assistant_id (cancels all in-flight runs for that assistant).
 
         Steps:
         - Validate arguments (one usage pattern or the other).
@@ -2426,10 +2501,18 @@ class Runs(Authenticated):
             * If 'pending', set to 'interrupted' or delete (if action='rollback' and not actively queued).
             * If 'running', the worker will pick up the message.
             * Otherwise, log a warning for non-cancelable states.
-        - 404 if no runs are found or authorized.
+        - 404 if no runs are found or authorized (unless assistant_id is provided).
         """
         # 1. Validate arguments
-        if status is not None:
+        if assistant_id is not None:
+            # If assistant_id is set, user must NOT specify other filters
+            if thread_id is not None or run_ids is not None or status is not None:
+                raise HTTPException(
+                    status_code=422,
+                    detail="Cannot specify 'thread_id', 'run_ids', or 'status' when using 'assistant_id'",
+                )
+            assistant_id = _ensure_uuid(assistant_id)
+        elif status is not None:
             # If status is set, user must NOT specify thread_id or run_ids
             if thread_id is not None or run_ids is not None:
                 raise HTTPException(
@@ -2441,7 +2524,7 @@ class Runs(Authenticated):
             if thread_id is None or run_ids is None:
                 raise HTTPException(
                     status_code=422,
-                    detail="Must provide either a status or both 'thread_id' and 'run_ids'",
+                    detail="Must provide either a status, an assistant_id, or both 'thread_id' and 'run_ids'",
                 )
 
         # Convert and normalize inputs
@@ -2476,7 +2559,12 @@ class Runs(Authenticated):
             """
             Check whether a run in `conn.store["runs"]` meets the selection criteria.
             """
-            if status_list:
+            if assistant_id is not None:
+                return r["assistant_id"] == assistant_id and r["status"] in (
+                    "pending",
+                    "running",
+                )
+            elif status_list:
                 return r["status"] in status_list
             else:
                 return r["thread_id"] == thread_id and r["run_id"] in run_ids  # type: ignore
@@ -2497,6 +2585,9 @@ class Runs(Authenticated):
             # on thread. If your filters also apply to runs, you might do more checks here.
 
         if not candidate_runs:
+            # When cancelling by assistant_id, it's valid to have no runs
+            if assistant_id is not None:
+                return
             raise HTTPException(status_code=404, detail="No runs found to cancel.")
 
         stream_manager = get_stream_manager()
@@ -2545,6 +2636,9 @@ class Runs(Authenticated):
                 )
 
         if not cancelable_runs:
+            # When cancelling by assistant_id, it's valid to have no cancelable runs
+            if assistant_id is not None:
+                return
             raise HTTPException(
                 status_code=404,
                 detail="No matching runs to cancel. Please verify the thread ID and run IDs are correct, and the runs haven't been deleted or completed.",
@@ -2671,7 +2765,10 @@ class Runs(Authenticated):
                         await Runs.Stream.check_run_stream_auth(run_id, thread_id, ctx)
                     except HTTPException as e:
                         raise WrappedHTTPException(e) from None
-                    run = await Runs.get(conn, run_id, thread_id=thread_id, ctx=ctx)
+                    run_iter = await Runs.get(
+                        conn, run_id, thread_id=thread_id, ctx=ctx
+                    )
+                    run = await anext(run_iter, None)
 
                     for message in get_stream_manager().restore_messages(
                         run_id, thread_id, last_event_id
@@ -2727,7 +2824,13 @@ class Runs(Authenticated):
                                     and mode.startswith("messages")
                                 )
                             ):
-                                yield mode.encode(), payload, id
+                                # We only return a stream ID if the run is resumable
+                                stream_id = (
+                                    id
+                                    if run.get("kwargs", {}).get("resumable")
+                                    else None
+                                )
+                                yield mode.encode(), payload, stream_id
                                 logger.debug(
                                     "Streamed run event",
                                     run_id=str(run_id),

{langgraph_runtime_inmem-0.20.1.dist-info → langgraph_runtime_inmem-0.21.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-runtime-inmem
-Version: 0.20.1
+Version: 0.21.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.20.1.dist-info → langgraph_runtime_inmem-0.21.0.dist-info}/RECORD

@@ -1,13 +1,13 @@
-langgraph_runtime_inmem/__init__.py,sha256=e4M7aySmFiZUS_yTkC-q-Qi2j5olmmHDojVLRwD-HMU,311
-langgraph_runtime_inmem/checkpoint.py,sha256=nc1G8DqVdIu-ibjKTqXfbPfMbAsKjPObKqegrSzo6Po,4432
+langgraph_runtime_inmem/__init__.py,sha256=oQHrzUbBlmokOOOztcFB8u7eCJvS0aPyNTrKSpqJ0to,311
+langgraph_runtime_inmem/checkpoint.py,sha256=TOuvWt3sqQPCmLjr1HZr6JAsinqUmmFr1hhhCbp2Lzo,6728
 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=qNK_-isTB92kQi3vVSt84__gMG02JUqmkNh-9LURexo,114772
+langgraph_runtime_inmem/ops.py,sha256=Im4G26eN7vLWELvj7WZQhm9x6UxzpP48-Bytye1v2pU,119002
 langgraph_runtime_inmem/queue.py,sha256=WM6ZJu25QPVjFXeJYW06GALLUgRsnRrA4YdypR0oG0U,9584
 langgraph_runtime_inmem/retry.py,sha256=XmldOP4e_H5s264CagJRVnQMDFcEJR_dldVR1Hm5XvM,763
 langgraph_runtime_inmem/store.py,sha256=rTfL1JJvd-j4xjTrL8qDcynaWF6gUJ9-GDVwH0NBD_I,3506
-langgraph_runtime_inmem-0.20.1.dist-info/METADATA,sha256=nMzYXp5OXuPOROcMYfi8EEAa-8ENdpX5t5H35xV1ww4,570
-langgraph_runtime_inmem-0.20.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-langgraph_runtime_inmem-0.20.1.dist-info/RECORD,,
+langgraph_runtime_inmem-0.21.0.dist-info/METADATA,sha256=CO0H61LlKVGta_vsiopcmGNdV8hbEGuXTp-_nZXhtbA,570
+langgraph_runtime_inmem-0.21.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+langgraph_runtime_inmem-0.21.0.dist-info/RECORD,,