langgraph-runtime-inmem 0.28.0__tar.gz → 0.29.0.dev1__tar.gz

{langgraph_runtime_inmem-0.28.0 → langgraph_runtime_inmem-0.29.0.dev1}/.gitignore

@@ -1,5 +1,6 @@
 *.env
 .env.gcp.yaml
+.worktrees/
 postgres-volume/
 redis-volume/
 

{langgraph_runtime_inmem-0.28.0 → langgraph_runtime_inmem-0.29.0.dev1}/PKG-INFO

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

{langgraph_runtime_inmem-0.28.0 → langgraph_runtime_inmem-0.29.0.dev1}/langgraph_runtime_inmem/__init__.py

@@ -10,7 +10,7 @@ from langgraph_runtime_inmem import (
     store,
 )
 
-__version__ = "0.28.0"
+__version__ = "0.29.0.dev1"
 __all__ = [
     "ops",
     "database",

{langgraph_runtime_inmem-0.28.0 → langgraph_runtime_inmem-0.29.0.dev1}/langgraph_runtime_inmem/checkpoint.py

@@ -241,8 +241,47 @@ def Checkpointer(*args, unpack_hook=None, **kwargs):
     if unpack_hook is not None:
         from langgraph_api.serde import Serializer  # noqa: PLC0415
 
+        # Prefer the API-level feature flag when available; older
+        # langgraph-api versions may not define it yet.
+        try:
+            from langgraph_api.feature_flags import (  # noqa: PLC0415
+                DELTA_CHANNEL_SUPPORT,
+            )
+        except ImportError:
+            DELTA_CHANNEL_SUPPORT = False
+
+        # DeltaChannel snapshots only exist on langgraph >= 1.2; on older
+        # installs the ``EXT_DELTA_SNAPSHOT`` codepoint can never appear in
+        # serialized payloads, so the bare ``unpack_hook`` is sufficient.
+        if DELTA_CHANNEL_SUPPORT:
+            from langgraph.checkpoint.serde.jsonplus import (  # noqa: PLC0415
+                EXT_DELTA_SNAPSHOT,  # ty: ignore[unresolved-import]
+            )
+            from langgraph.checkpoint.serde.types import (  # noqa: PLC0415
+                _DeltaSnapshot,  # ty: ignore[unresolved-import]
+            )
+
+            _inner_hook = unpack_hook
+
+            def _delta_aware_hook(code: int, data: bytes) -> Any:
+                if code == EXT_DELTA_SNAPSHOT:
+                    import ormsgpack  # noqa: PLC0415
+
+                    return _DeltaSnapshot(
+                        ormsgpack.unpackb(
+                            data,
+                            ext_hook=_delta_aware_hook,
+                            option=ormsgpack.OPT_NON_STR_KEYS,
+                        )
+                    )
+                return _inner_hook(code, data)
+
+            ext_hook = _delta_aware_hook
+        else:
+            ext_hook = unpack_hook
+
         saver = InMemorySaver(
-            serde=Serializer(__unpack_ext_hook__=unpack_hook),
+            serde=Serializer(__unpack_ext_hook__=ext_hook),
             __persistence_hook__=register_persistent_dict,
             **kwargs,
         )

{langgraph_runtime_inmem-0.28.0 → langgraph_runtime_inmem-0.29.0.dev1}/langgraph_runtime_inmem/ops.py

@@ -1949,6 +1949,27 @@ class Threads(Authenticated):
             stream_modes: list[ThreadStreamMode],
             ctx: Auth.types.BaseAuthContext | None = None,
         ) -> AsyncIterator[tuple[bytes, bytes, bytes | None]]:
+            async for (
+                event,
+                payload,
+                stream_id,
+                _run_id,
+            ) in Threads.Stream.join_event_streaming(
+                thread_id,
+                last_event_id=last_event_id,
+                stream_modes=stream_modes,
+                ctx=ctx,
+            ):
+                yield event, payload, stream_id
+
+        @staticmethod
+        async def join_event_streaming(
+            thread_id: UUID,
+            *,
+            last_event_id: str | None = None,
+            stream_modes: list[ThreadStreamMode],
+            ctx: Auth.types.BaseAuthContext | None = None,
+        ) -> AsyncIterator[tuple[bytes, bytes, bytes | None, str | None]]:
             """Stream the thread output."""
             await Threads.Stream.check_thread_stream_auth(thread_id, ctx)
 
@@ -1986,11 +2007,14 @@ class Threads(Authenticated):
 
                     # Restore messages if resuming from a specific event
                     if last_event_id is not None:
-                        # Collect all events from all message stores for this thread
+                        # ``message_stores`` is keyed by ``UUID`` (see
+                        # :meth:`StreamManager.put`). Callers can hand us
+                        # ``thread_id`` as either ``str`` or ``UUID``, so
+                        # normalize before the lookup — otherwise replay
+                        # always misses and yields nothing.
+                        store_key = _ensure_uuid(thread_id)
                         all_events = []
-                        for run_id in stream_manager.message_stores.get(
-                            str(thread_id), []
-                        ):
+                        for run_id in stream_manager.message_stores.get(store_key, []):
                             for message in stream_manager.restore_messages(
                                 run_id, thread_id, last_event_id
                             ):
@@ -2020,9 +2044,20 @@ class Threads(Authenticated):
                                     event_bytes,
                                     message_bytes,
                                     message.id,
+                                    str(run_id),
                                 )
 
-                    # Listen for live messages from all queues
+                    # Listen for live messages from all queues.
+                    #
+                    # Hot loop is non-blocking: a burst of N events drains in
+                    # one outer-loop iteration via ``get_nowait``, instead of
+                    # the previous "one event per queue per 200ms timeout"
+                    # pattern that throttled fast-publishing runs (the empty
+                    # thread-stream queue alone forced every iteration to
+                    # wait the full timeout). When everything is idle we fall
+                    # back to a short ``asyncio.sleep`` so new runs joining
+                    # the thread get picked up by the next ``subscribe``
+                    # without burning CPU.
                     while True:
                         # Refresh queues to pick up any new runs that joined this thread
                         new_queue_tuples = await Threads.Stream.subscribe(
@@ -2032,40 +2067,69 @@ class Threads(Authenticated):
                         for run_id, queue in new_queue_tuples:
                             created_queues.append((run_id, queue))
 
+                        drained_any = False
                         for run_id, queue in created_queues:
-                            try:
-                                message = await asyncio.wait_for(
-                                    queue.get(), timeout=0.2
-                                )
-                                decoded = decode_stream_message(
-                                    message.data, channel=message.topic
-                                )
+                            while True:
+                                try:
+                                    message = queue.get_nowait()
+                                except asyncio.QueueEmpty:
+                                    break
+                                try:
+                                    decoded = decode_stream_message(
+                                        message.data, channel=message.topic
+                                    )
+                                except (ValueError, KeyError):
+                                    continue
                                 event = decoded.event_bytes
                                 event_name = event.decode("utf-8")
                                 payload = decoded.message_bytes
 
                                 if event == b"control" and payload == b"done":
+                                    # Don't shadow the queue-iteration
+                                    # ``run_id`` with the topic-extracted
+                                    # string — non-control events later in
+                                    # this drain pass would yield the
+                                    # rebound value. Wire output is
+                                    # identical (``str(UUID)`` matches the
+                                    # topic suffix), but the rebinding is
+                                    # fragile if the topic format moves.
                                     topic = message.topic.decode()
-                                    run_id = topic.split("run:")[1].split(":")[0]
+                                    done_run_id = topic.split("run:")[1].split(":")[0]
                                     meta_event = b"metadata"
                                     meta_payload = orjson.dumps(
-                                        {"status": "run_done", "run_id": run_id}
+                                        {"status": "run_done", "run_id": done_run_id}
                                     )
                                     if not should_filter_event(
                                         "metadata", meta_payload
                                     ):
-                                        yield (meta_event, meta_payload, message.id)
+                                        yield (
+                                            meta_event,
+                                            meta_payload,
+                                            message.id,
+                                            done_run_id,
+                                        )
+                                        drained_any = True
                                 else:
                                     if not should_filter_event(event_name, payload):
-                                        yield (event, payload, message.id)
-
-                            except TimeoutError:
-                                continue
-                            except (ValueError, KeyError):
-                                continue
-
-                        # Yield execution to other tasks to prevent event loop starvation
-                        await asyncio.sleep(0)
+                                        yield (
+                                            event,
+                                            payload,
+                                            message.id,
+                                            str(run_id),
+                                        )
+                                        drained_any = True
+
+                        if drained_any:
+                            # Yield once so other tasks (worker, send) can
+                            # advance, then loop immediately to drain any
+                            # follow-up burst.
+                            await asyncio.sleep(0)
+                        else:
+                            # All queues empty — short poll interval keeps
+                            # ``subscribe`` rechecking for newly-spawned
+                            # runs and lets the worker emit without a
+                            # >5-events-per-second delivery cap.
+                            await asyncio.sleep(0.02)
 
             except WrappedHTTPException as e:
                 raise e.http_exception from None
@@ -2913,12 +2977,18 @@ class Runs(Authenticated):
                 run_id
             ):
                 for control_queue in control_queues:
-                    try:
-                        while True:
-                            control_msg = control_queue.get()
-                            await queue.put(control_msg)
-                    except asyncio.QueueEmpty:
-                        pass
+                    # NOTE: must use ``get_nowait``. ``asyncio.Queue.get`` is a
+                    # coroutine — calling it without ``await`` returns a
+                    # coroutine object and never raises ``QueueEmpty``, which
+                    # turns this drain into an infinite loop that blocks the
+                    # event loop (the coroutine objects get pushed straight
+                    # into ``queue`` via ``put_nowait`` with no yield point).
+                    while True:
+                        try:
+                            control_msg = control_queue.get_nowait()
+                        except asyncio.QueueEmpty:
+                            break
+                        await queue.put(control_msg)
             return queue
 
         @staticmethod
@@ -3502,16 +3572,18 @@ class Crons(Authenticated):
         ctx: Auth.types.BaseAuthContext | None = None,
         sort_by: str | None = None,
         sort_order: Literal["asc", "desc"] | None = None,
+        metadata: dict | None = None,
     ) -> tuple[AsyncIterator[Cron], int | None]:
         filters = await Crons.handle_event(
             ctx,
             "search",
-            Auth.types.CronsSearch(
-                assistant_id=assistant_id,
-                thread_id=thread_id,
-                limit=limit,
-                offset=offset,
-            ),
+            {
+                "assistant_id": assistant_id,
+                "thread_id": thread_id,
+                "limit": limit,
+                "offset": offset,
+                "metadata": metadata or {},
+            },
         )
 
         if thread_id:
@@ -3535,6 +3607,7 @@ class Crons(Authenticated):
             if (assistant_id is None or str(c["assistant_id"]) == str(assistant_id))
             and (thread_id is None or str(c.get("thread_id")) == str(thread_id))
             and (enabled is None or c.get("enabled") == enabled)
+            and (not metadata or is_jsonb_contained(c.get("metadata", {}), metadata))
             and (not filters or _check_filter_match(c.get("metadata", {}), filters))
         ]
 
@@ -3616,17 +3689,19 @@ class Crons(Authenticated):
         assistant_id: UUID | None = None,
         thread_id: UUID | None = None,
         ctx: Auth.types.BaseAuthContext | None = None,
+        metadata: dict | None = None,
     ) -> int:
         """Get count of crons."""
         filters = await Crons.handle_event(
             ctx,
             "search",
-            Auth.types.CronsSearch(
-                assistant_id=assistant_id,
-                thread_id=thread_id,
-                limit=0,
-                offset=0,
-            ),
+            {
+                "assistant_id": assistant_id,
+                "thread_id": thread_id,
+                "limit": 0,
+                "offset": 0,
+                "metadata": metadata or {},
+            },
         )
 
         if thread_id:
@@ -3649,6 +3724,8 @@ class Crons(Authenticated):
                 continue
             if thread_id is not None and str(c.get("thread_id")) != str(thread_id):
                 continue
+            if metadata and not is_jsonb_contained(c.get("metadata", {}), metadata):
+                continue
             if filters and not _check_filter_match(c.get("metadata", {}), filters):
                 continue
             filtered_crons.append(c)

{langgraph_runtime_inmem-0.28.0 → langgraph_runtime_inmem-0.29.0.dev1}/langgraph_runtime_inmem/queue.py

@@ -102,9 +102,9 @@ async def queue():
         await logger.awarning(
             "Heads up: You've set --allow-blocking, which allows synchronous blocking I/O operations."
             " Be aware that blocking code in one run may tie up the shared event loop"
-            " and slow down ALL other server operations. For best performance, either convert blocking"
-            " code to async patterns or set BG_JOB_ISOLATED_LOOPS=true in production"
-            " to isolate each run in its own event loop."
+            " and slow down ALL other server operations. For best performance, use async drivers"
+            " (e.g., aiohttp instead of requests, asyncpg instead of psycopg2). If switching to an"
+            " async driver isn't possible, wrap the blocking call in asyncio.to_thread()."
         )
     else:
         bb = _enable_blockbuster()
@@ -369,13 +369,11 @@ def _patch_blocking_error():
             "Heads up! LangGraph dev identified a synchronous blocking call in your code. "
             "When running in an ASGI web server, blocking calls can degrade performance for everyone since they tie up the event loop.\n\n"
             "Here are your options to fix this:\n\n"
-            "1. Best approach: Convert any blocking code to use async/await patterns\n"
-            "   For example, use 'await aiohttp.get()' instead of 'requests.get()'\n\n"
-            "2. Quick fix: Move blocking operations to a separate thread\n"
+            "1. Best approach: Use an async driver so the call is non-blocking\n"
+            "   For example, use 'await aiohttp.get()' instead of 'requests.get()', or asyncpg instead of psycopg2.\n\n"
+            "2. If an async driver isn't available: wrap the blocking call in a thread\n"
             "   Example: 'await asyncio.to_thread(your_blocking_function)'\n\n"
-            "3. Override (if you can't change the code):\n"
-            "   - For development: Run 'langgraph dev --allow-blocking'\n"
-            "   - For deployment: Set 'BG_JOB_ISOLATED_LOOPS=true' environment variable\n\n"
+            "3. Dev-only override: run 'langgraph dev --allow-blocking'\n\n"
             "These blocking operations can prevent health checks and slow down other runs in your deployment. "
             "Following these recommendations will help keep your LangGraph application running smoothly!"
         )