langgraph-runtime-inmem 0.37.0.dev5__tar.gz → 0.37.0rc2__tar.gz

{langgraph_runtime_inmem-0.37.0.dev5 → langgraph_runtime_inmem-0.37.0rc2}/PKG-INFO

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

{langgraph_runtime_inmem-0.37.0.dev5 → langgraph_runtime_inmem-0.37.0rc2}/langgraph_runtime_inmem/__init__.py

@@ -11,7 +11,7 @@ from langgraph_runtime_inmem import (
     store,
 )
 
-__version__ = "0.37.0.dev5"
+__version__ = "0.37.0rc2"
 __all__ = [
     "ops",
     "database",

{langgraph_runtime_inmem-0.37.0.dev5 → langgraph_runtime_inmem-0.37.0rc2}/langgraph_runtime_inmem/database.py

@@ -195,28 +195,15 @@ def _load_ops_file() -> None:
 
 
 def upgrade_thread_status_facts(store: dict[str, Any]) -> None:
-    """Bring threads from ops files saved by older versions in line with how
-    status is derived now, as migration 000066 does for postgres.
-
-    Interrupted threads are recorded as having next steps; other threads count as
-    having none until their next snapshot. Threads whose status was `error` are
-    recorded as having failed. Cancels, which older versions stored in the thread's
-    error, are cleared when the error reads as exactly one; anything else, encrypted
-    errors included, stays.
+    """Ensure fact maps exist for ops files saved by older versions.
+
+    Migration 000066 only adds nullable has_next / failed columns; it does not
+    backfill. Writers fill the facts on the next status write, and status
+    re-derivation keeps the stored status while either fact is still unknown.
+    Cancels that older versions left in ``error`` are left as-is.
     """
-    has_next = store.setdefault("thread_has_next", {})
-    failed = store.setdefault("thread_failed", {})
-    for thread in store["threads"]:
-        if thread.get("status") == "interrupted":
-            has_next.setdefault(thread["thread_id"], True)
-        failed.setdefault(thread["thread_id"], thread.get("status") == "error")
-        error = thread.get("error")
-        if (
-            isinstance(error, dict)
-            and "__encryption_context__" not in error
-            and error.get("error") in ("UserInterrupt", "UserRollback")
-        ):
-            thread["error"] = None
+    store.setdefault("thread_has_next", {})
+    store.setdefault("thread_failed", {})
 
 
 def _set_aside_ops_file(reason: Exception) -> None:

{langgraph_runtime_inmem-0.37.0.dev5 → langgraph_runtime_inmem-0.37.0rc2}/langgraph_runtime_inmem/ops.py

@@ -122,6 +122,34 @@ def _thread_failure(exception: BaseException | None) -> BaseException | None:
     return None if isinstance(exception, UserInterrupt) else exception
 
 
+def _derive_thread_status(
+    *,
+    has_active_runs: bool,
+    failed: bool | None,
+    has_next: bool | None,
+    existing_status: ThreadStatus,
+) -> ThreadStatus:
+    """The one rule for a thread's status from known facts.
+
+    busy if a run is active; otherwise error if the last run failed; otherwise
+    interrupted if the graph has next steps; otherwise keep ``existing_status``
+    when ``failed`` or ``has_next`` is still unknown (None); otherwise idle.
+
+    A leftover busy with no active runs becomes idle.
+    """
+    if has_active_runs:
+        return "busy"
+    if failed:
+        return "error"
+    if has_next:
+        return "interrupted"
+    if failed is None or has_next is None:
+        if existing_status == "busy":
+            return "idle"
+        return existing_status
+    return "idle"
+
+
 def _thread_status(
     conn: InMemConnectionProto,
     thread_id: UUID,
@@ -131,27 +159,29 @@ def _thread_status(
 ) -> ThreadStatus:
     """The one rule for a thread's status, used by every write that changes it.
 
-    busy if a run on the thread is pending or running; otherwise error if the last
-    run failed; otherwise interrupted if the graph has next steps (an interrupt or a
-    breakpoint); otherwise idle.
-
     A nil ``failed`` or ``has_next`` means the caller doesn't know the fact, so it is
-    read from what is stored on the thread; an unknown fact counts as no.
+    read from what is stored on the thread; a fact still missing from the store is
+    unknown and keeps the thread's current status (see ``_derive_thread_status``).
     """
-    if any(
+    has_active_runs = any(
         r["thread_id"] == thread_id and r["status"] in ("pending", "running")
         for r in conn.store["runs"]
-    ):
-        return "busy"
-    if failed is None:
-        failed = _thread_failed(conn).get(thread_id, False)
-    if failed:
-        return "error"
-    if has_next is None:
-        has_next = _thread_has_next(conn).get(thread_id, False)
-    if has_next:
-        return "interrupted"
-    return "idle"
+    )
+    if failed is None and thread_id in _thread_failed(conn):
+        failed = _thread_failed(conn)[thread_id]
+    if has_next is None and thread_id in _thread_has_next(conn):
+        has_next = _thread_has_next(conn)[thread_id]
+    existing_status: ThreadStatus = "idle"
+    for thread in conn.store["threads"]:
+        if thread["thread_id"] == thread_id:
+            existing_status = thread["status"]
+            break
+    return _derive_thread_status(
+        has_active_runs=has_active_runs,
+        failed=failed,
+        has_next=has_next,
+        existing_status=existing_status,
+    )
 
 
 async def _save_thread_status(
@@ -948,15 +978,24 @@ def is_jsonb_contained(superset: dict[str, Any], subset: dict[str, Any]) -> bool
     """
     if not isinstance(superset, dict):
         return False
-    for key, value in subset.items():
-        if key not in superset:
-            return False
-        if isinstance(value, dict) and isinstance(superset[key], dict):
-            if not is_jsonb_contained(superset[key], value):
-                return False
-        elif superset[key] != value:
-            return False
-    return True
+    return all(
+        key in superset and _is_jsonb_value_contained(superset[key], value)
+        for key, value in subset.items()
+    )
+
+
+def _is_jsonb_value_contained(superset: Any, subset: Any) -> bool:
+    """Implements Postgres' @> semantics for arbitrary JSON values."""
+    if isinstance(subset, dict):
+        return isinstance(superset, dict) and is_jsonb_contained(superset, subset)
+    if isinstance(subset, list):
+        return isinstance(superset, list) and all(
+            any(_is_jsonb_value_contained(item, sub_item) for item in superset)
+            for sub_item in subset
+        )
+    if isinstance(superset, bool) or isinstance(subset, bool):
+        return superset is subset
+    return superset == subset
 
 
 def bytes_decoder(obj):
@@ -1060,6 +1099,7 @@ class Threads(Authenticated):
         sort_order: str | None = None,
         select: list[ThreadSelectField] | None = None,
         extract: dict[str, str] | None = None,
+        exclude_metadata: list[dict[str, Any]] | None = None,
         ctx: Auth.types.BaseAuthContext | None = None,
     ) -> tuple[AsyncIterator[Thread], int]:
         threads = conn.store["threads"]
@@ -1102,6 +1142,12 @@ class Threads(Authenticated):
             if metadata and not is_jsonb_contained(thread["metadata"], metadata):
                 continue
 
+            if exclude_metadata and any(
+                is_jsonb_contained(thread["metadata"], excluded)
+                for excluded in exclude_metadata
+            ):
+                continue
+
             if (
                 values
                 and "values" in thread
@@ -1683,19 +1729,30 @@ class Threads(Authenticated):
             # The copy gets the original's checkpoints below, so it starts where the
             # original stands: same values, interrupts and error, and the same fact
             # about whether its graph has next steps. Its status comes from those,
-            # by the usual rule: the original's runs are not the copy's.
+            # by the usual rule: the original's runs are not the copy's. Missing
+            # facts keep the original's status (except a stale busy → idle).
             now = datetime.now(tz=UTC)
+            src_failed = (
+                _thread_failed(conn)[thread_id]
+                if thread_id in _thread_failed(conn)
+                else None
+            )
+            src_has_next = (
+                _thread_has_next(conn)[thread_id]
+                if thread_id in _thread_has_next(conn)
+                else None
+            )
             new_thread: Thread = {
                 "thread_id": new_thread_id,
                 "created_at": now,
                 "updated_at": now,
                 "state_updated_at": now,
                 "metadata": copy.deepcopy(original_thread["metadata"]),
-                "status": _thread_status(
-                    conn,
-                    new_thread_id,
-                    failed=_thread_failed(conn).get(thread_id, False),
-                    has_next=_thread_has_next(conn).get(thread_id, False),
+                "status": _derive_thread_status(
+                    has_active_runs=False,
+                    failed=src_failed,
+                    has_next=src_has_next,
+                    existing_status=original_thread["status"],
                 ),
                 "config": {},
                 "values": copy.deepcopy(original_thread.get("values")),
@@ -2239,9 +2296,16 @@ class Threads(Authenticated):
             last_event_id: str | None = None,
             stream_modes: list[ThreadStreamMode],
             ctx: Auth.types.BaseAuthContext | None = None,
+            auth_filters: Auth.types.FilterType | None = None,
         ) -> AsyncIterator[tuple[bytes, bytes, bytes | None, str | None]]:
-            """Stream the thread output."""
-            await Threads.Stream.check_thread_stream_auth(thread_id, ctx)
+            """Stream the thread output.
+
+            ``auth_filters`` comes from a ``check_thread_stream_auth`` the
+            caller already ran, so the read handler doesn't run twice. With
+            ``None``, the check runs here.
+            """
+            if auth_filters is None:
+                await Threads.Stream.check_thread_stream_auth(thread_id, ctx)
 
             from langgraph_api.utils.stream_codec import (  # noqa: PLC0415
                 decode_stream_message,
@@ -2441,7 +2505,11 @@ class Threads(Authenticated):
         async def check_thread_stream_auth(
             thread_id: UUID,
             ctx: Auth.types.BaseAuthContext | None = None,
-        ) -> None:
+        ) -> Auth.types.FilterType:
+            """Raise 403/404 for a thread the caller can't read.
+
+            Returns the auth filters for ``join_event_streaming``.
+            """
             async with connect() as conn:
                 filters = await Threads.Stream.handle_event(
                     ctx,
@@ -2454,6 +2522,7 @@ class Threads(Authenticated):
                     )
                     if not thread:
                         raise HTTPException(status_code=404, detail="Thread not found")
+            return filters or {}
 
     @staticmethod
     async def count(
@@ -2462,6 +2531,7 @@ class Threads(Authenticated):
         metadata: MetadataInput = None,
         values: MetadataInput = None,
         status: ThreadStatus | None = None,
+        exclude_metadata: list[dict[str, Any]] | None = None,
         ctx: Auth.types.BaseAuthContext | None = None,
     ) -> int:
         """Get count of threads."""
@@ -2490,6 +2560,12 @@ class Threads(Authenticated):
             if metadata and not is_jsonb_contained(thread["metadata"], metadata):
                 continue
 
+            if exclude_metadata and any(
+                is_jsonb_contained(thread["metadata"], excluded)
+                for excluded in exclude_metadata
+            ):
+                continue
+
             if (
                 values
                 and "values" in thread
@@ -2813,6 +2889,8 @@ class Runs(Authenticated):
             if not _check_filter_match(existing_thread["metadata"], filters):
                 return _empty_generator()
 
+        _reject_existing_run(conn.store["runs"], run_id)
+
         if not existing_thread and (thread_id is None or if_not_exists == "create"):
             # Create new thread
             if thread_id is None:
@@ -2951,6 +3029,7 @@ class Runs(Authenticated):
             cancel_reason=None,
         )
         stored_run = new_run
+        encrypted_thread = None
         if encryption_enabled:
             # Unlike Go core, in-memory workers read nested run kwargs and thread
             # config directly from the store, so those containers must stay readable.
@@ -2958,14 +3037,16 @@ class Runs(Authenticated):
                 thread if not existing_thread else existing_thread,
                 "thread",
             )
+            stored_run = copy.deepcopy(new_run)
+            stored_run = Run(**await _encrypt_for_storage(stored_run, "run"))
+        _reject_existing_run(conn.store["runs"], run_id)
+        if encrypted_thread is not None:
             stored_thread = next(
                 t
                 for t in conn.store["threads"]
                 if t["thread_id"] == encrypted_thread["thread_id"]
             )
             stored_thread.update(encrypted_thread)
-            stored_run = copy.deepcopy(new_run)
-            stored_run = Run(**await _encrypt_for_storage(stored_run, "run"))
         conn.store["runs"].append(stored_run)
 
         async def _yield_new():
@@ -4433,6 +4514,11 @@ def _check_filter_match(
     return True
 
 
+def _reject_existing_run(runs: Sequence[Run], run_id: UUID | None) -> None:
+    if any(run["run_id"] == run_id for run in runs):
+        raise HTTPException(status_code=409, detail=f"Run {run_id} already exists")
+
+
 async def _empty_generator():
     if False:
         yield