langgraph-runtime-inmem 0.37.0.dev2__tar.gz → 0.37.0.dev4__tar.gz

{langgraph_runtime_inmem-0.37.0.dev2 → langgraph_runtime_inmem-0.37.0.dev4}/Makefile

@@ -16,4 +16,4 @@ bump-version:
 	uv run --with hatch hatch version $(VERSION_KIND)
 
 check-base-imports:
-	DATABASE_URI="foo" REDIS_URI="bar" uv run python -c "from langgraph_runtime_inmem import *"
+	DATABASE_URI="foo" REDIS_URI="bar" uv run python -c "from langgraph_runtime_inmem import *"

{langgraph_runtime_inmem-0.37.0.dev2 → langgraph_runtime_inmem-0.37.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-runtime-inmem
-Version: 0.37.0.dev2
+Version: 0.37.0.dev4
 Summary: Inmem implementation for the LangGraph API server.
 Author-email: Will Fu-Hinthorn <will@langchain.dev>
 License: Elastic-2.0
@@ -17,4 +17,3 @@ Description-Content-Type: text/markdown
 # LangGraph Runtime Inmem
 
 This is the inmem implementation of the LangGraph Runtime API.
-

{langgraph_runtime_inmem-0.37.0.dev2 → langgraph_runtime_inmem-0.37.0.dev4}/README.md

@@ -1,4 +1,3 @@
 # LangGraph Runtime Inmem
 
 This is the inmem implementation of the LangGraph Runtime API.
-

{langgraph_runtime_inmem-0.37.0.dev2 → langgraph_runtime_inmem-0.37.0.dev4}/langgraph_runtime_inmem/__init__.py

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

{langgraph_runtime_inmem-0.37.0.dev2 → langgraph_runtime_inmem-0.37.0.dev4}/langgraph_runtime_inmem/checkpoint.py

@@ -308,50 +308,3 @@ def Checkpointer(*args, unpack_hook=None, **kwargs):
 
 
 __all__ = ["Checkpointer"]
-
-
-def _nbytes(value: Any) -> int:
-    if isinstance(value, bytes | bytearray | memoryview):
-        return len(value)
-    if isinstance(value, tuple | list):
-        return sum(_nbytes(item) for item in value)
-    return 0
-
-
-async def thread_storage(conn: Any, thread_id: str) -> dict[str, Any]:
-    """Bytes a thread's checkpoints occupy in memory, per table and per channel.
-
-    Same shape as the postgres runtime's report, so one endpoint serves both.
-    """
-    saver = Checkpointer()
-    by_channel: dict[str, dict[str, int]] = {}
-    for (tid, _ns, channel, _version), blob in list(saver.blobs.items()):
-        if tid != thread_id:
-            continue
-        entry = by_channel.setdefault(channel, {"versions": 0, "bytes": 0})
-        entry["versions"] += 1
-        entry["bytes"] += _nbytes(blob)
-    checkpoint_count = checkpoint_bytes = 0
-    if thread_id in saver.storage:
-        for checkpoints in saver.storage[thread_id].values():
-            for stored in checkpoints.values():
-                checkpoint_count += 1
-                checkpoint_bytes += _nbytes(stored)
-    write_count = write_bytes = 0
-    for (tid, _ns, _checkpoint_id), writes in list(saver.writes.items()):
-        if tid != thread_id:
-            continue
-        for write in writes.values():
-            write_count += 1
-            write_bytes += _nbytes(write)
-    channel_bytes = sum(entry["bytes"] for entry in by_channel.values())
-    return {
-        "total_bytes": checkpoint_bytes + channel_bytes + write_bytes,
-        "checkpoints": {"count": checkpoint_count, "bytes": checkpoint_bytes},
-        "channel_values": {
-            "count": sum(entry["versions"] for entry in by_channel.values()),
-            "bytes": channel_bytes,
-            "by_channel": by_channel,
-        },
-        "pending_writes": {"count": write_count, "bytes": write_bytes},
-    }

{langgraph_runtime_inmem-0.37.0.dev2 → langgraph_runtime_inmem-0.37.0.dev4}/langgraph_runtime_inmem/database.py

@@ -97,6 +97,8 @@ class GlobalStore(PersistentDict):
         ]
         self["assistant_versions"] = []
         self["crons"] = []
+        self["thread_has_next"] = {}
+        self["thread_failed"] = {}
 
 
 OPS_FILENAME = os.path.join(".langgraph_api", ".langgraph_ops.pckl")
@@ -158,7 +160,10 @@ async def connect(
 
 
 def _load_ops_file() -> None:
-    """Load the saved ops file into ``GLOBAL_STORE``, setting it aside if unloadable."""
+    """Load the saved ops file into ``GLOBAL_STORE``, setting it aside if unloadable.
+
+    Runs the previous process left ``running`` are reset to ``pending`` to be retried.
+    """
     if not os.path.exists(OPS_FILENAME):
         return
 
@@ -175,6 +180,44 @@ def _load_ops_file() -> None:
         return
     GLOBAL_STORE.update(data)
 
+    # No worker has started yet, so a run saved as running was cut off by a crash.
+    # Left running, it blocks every later run on its thread (Runs.next skips the thread).
+    orphaned = [r for r in GLOBAL_STORE.get("runs") or [] if r["status"] == "running"]
+    now = datetime.now(UTC)
+    for run in orphaned:
+        run["status"] = "pending"
+        run["updated_at"] = now
+    if orphaned:
+        logger.warning(
+            "Retrying runs left running by a previous process that did not shut down cleanly",
+            run_ids=[str(r["run_id"]) for r in orphaned],
+        )
+
+
+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.
+    """
+    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
+
 
 def _set_aside_ops_file(reason: Exception) -> None:
     """Rename an unloadable ops file to ``<file>.bak-<UTC timestamp>`` and log why."""
@@ -262,6 +305,7 @@ async def start_pool() -> None:
     for k in ["runs", "threads", "assistant_versions", "assistants"]:
         if not GLOBAL_STORE.get(k):
             GLOBAL_STORE[k] = []
+    upgrade_thread_status_facts(GLOBAL_STORE)
     # Remove agents that were created by the system to avoid removed graphs
     if GLOBAL_STORE.get("assistants"):
         for a in GLOBAL_STORE["assistants"]:
@@ -272,8 +316,10 @@ async def start_pool() -> None:
     for k in ["crons"]:
         if not GLOBAL_STORE.get(k):
             GLOBAL_STORE[k] = []
-    register_persistent_dict(GLOBAL_STORE)
+    # Flushed in this order: a crash between the two writes then over-counts an
+    # attempt rather than letting a retried run skip one.
     register_persistent_dict(GLOBAL_RETRY_COUNTER._counters)
+    register_persistent_dict(GLOBAL_STORE)
     await start_stream()
 
 

{langgraph_runtime_inmem-0.37.0.dev2 → langgraph_runtime_inmem-0.37.0.dev4}/langgraph_runtime_inmem/ops.py

@@ -93,6 +93,120 @@ def _using_encryption() -> bool:
     return using_encryption()
 
 
+def _thread_has_next(conn: InMemConnectionProto) -> dict[UUID, bool]:
+    """Whether each thread's graph has next steps, as of its latest snapshot.
+
+    Kept beside the threads rather than on them, because thread dicts are returned
+    to callers as they are and this is internal. A missing entry means unknown.
+    """
+    return conn.store.setdefault("thread_has_next", {})
+
+
+def _thread_failed(conn: InMemConnectionProto) -> dict[UUID, bool]:
+    """Whether each thread's last reported run failed.
+
+    Kept beside the threads for the same reason as ``_thread_has_next``: it is
+    internal, and a missing entry means unknown.
+    """
+    return conn.store.setdefault("thread_failed", {})
+
+
+def _thread_failure(exception: BaseException | None) -> BaseException | None:
+    """The exception if the run really failed, and None for a user cancel or rollback.
+
+    Those are not failures, so they don't belong in the thread's error; the reason
+    for a cancel is recorded on the run instead (``cancel_reason``).
+    """
+    from langgraph_api.errors import UserInterrupt  # noqa: PLC0415
+
+    return None if isinstance(exception, UserInterrupt) else exception
+
+
+def _thread_status(
+    conn: InMemConnectionProto,
+    thread_id: UUID,
+    *,
+    failed: bool | None = None,
+    has_next: bool | None = None,
+) -> 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.
+    """
+    if 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"
+
+
+async def _save_thread_status(
+    conn: InMemConnectionProto,
+    thread_id: UUID,
+    thread: dict[str, Any],
+    stored_thread: dict[str, Any],
+    checkpoint: CheckpointPayload | None,
+    exception: BaseException | None,
+    now: datetime,
+) -> None:
+    """Write a thread's status and error from the facts this update knows.
+
+    Every writer derives the status from the thread's facts with the same rule.
+    Without a checkpoint there is nothing to replace values, interrupts and
+    has_next with, so the thread keeps the ones it already has. has_next is
+    recorded only once the thread is saved, so a failed save can't leave the two
+    apart.
+    """
+    from langgraph_api.serde import json_dumpb, json_loads  # noqa: PLC0415
+
+    failure = _thread_failure(exception)
+    has_next = None if checkpoint is None else bool(checkpoint["next"])
+
+    update: dict = {
+        "updated_at": now,
+        "state_updated_at": now,
+        "status": _thread_status(
+            conn, thread_id, failed=failure is not None, has_next=has_next
+        ),
+        "error": json_loads(json_dumpb(failure)) if failure else None,
+    }
+    if checkpoint is not None:
+        update["values"] = json_loads(json_dumpb(checkpoint["values"]))
+        update["interrupts"] = json_loads(
+            json_dumpb(
+                {
+                    t["id"]: [_patch_interrupt(i) for i in t["interrupts"]]
+                    for t in checkpoint["tasks"]
+                    if t.get("interrupts")
+                }
+            )
+        )
+    thread.update(update)
+    if _using_encryption():
+        encrypted_thread = await _encrypt_for_storage(thread, "thread")
+        stored_thread.clear()
+        stored_thread.update(encrypted_thread)
+    # Recorded only once the thread is saved, so a failed save can't leave the
+    # facts apart from the thread.
+    if has_next is not None:
+        _thread_has_next(conn)[thread_id] = has_next
+    _thread_failed(conn)[thread_id] = failure is not None
+
+
 def _run_stream_mode_matches(event_mode: str, stream_mode: list[str] | None) -> bool:
     """Return True if a published run-stream event matches the join filter."""
     if not stream_mode:
@@ -920,6 +1034,14 @@ def _patch_interrupt(
         }
 
 
+def _nbytes(value: Any) -> int:
+    if isinstance(value, bytes | bytearray | memoryview):
+        return len(value)
+    if isinstance(value, tuple | list):
+        return sum(_nbytes(item) for item in value)
+    return 0
+
+
 class Threads(Authenticated):
     resource = "threads"
 
@@ -1110,6 +1232,52 @@ class Threads(Authenticated):
 
         return _yield_result()
 
+    @staticmethod
+    async def storage(
+        conn: InMemConnectionProto,
+        thread_id: UUID | str,
+        ctx: Auth.types.BaseAuthContext | None = None,
+    ) -> dict[str, Any]:
+        """Bytes a thread's checkpoints occupy in memory, per table and per channel.
+
+        Same shape as the postgres runtime's report, so one endpoint serves both.
+        Raises 404 if the thread doesn't exist or the auth handler hides it.
+        """
+        await Threads.get(conn, thread_id, ctx=ctx)
+        thread_id = str(thread_id)
+        saver = Checkpointer()
+        by_channel: dict[str, dict[str, int]] = {}
+        for (tid, _ns, channel, _version), blob in list(saver.blobs.items()):
+            if tid != thread_id:
+                continue
+            entry = by_channel.setdefault(channel, {"versions": 0, "bytes": 0})
+            entry["versions"] += 1
+            entry["bytes"] += _nbytes(blob)
+        checkpoint_count = checkpoint_bytes = 0
+        if thread_id in saver.storage:
+            for checkpoints in saver.storage[thread_id].values():
+                for stored in checkpoints.values():
+                    checkpoint_count += 1
+                    checkpoint_bytes += _nbytes(stored)
+        write_count = write_bytes = 0
+        for (tid, _ns, _checkpoint_id), writes in list(saver.writes.items()):
+            if tid != thread_id:
+                continue
+            for write in writes.values():
+                write_count += 1
+                write_bytes += _nbytes(write)
+        channel_bytes = sum(entry["bytes"] for entry in by_channel.values())
+        return {
+            "total_bytes": checkpoint_bytes + channel_bytes + write_bytes,
+            "checkpoints": {"count": checkpoint_count, "bytes": checkpoint_bytes},
+            "channel_values": {
+                "count": sum(entry["versions"] for entry in by_channel.values()),
+                "bytes": channel_bytes,
+                "by_channel": by_channel,
+            },
+            "pending_writes": {"count": write_count, "bytes": write_bytes},
+        }
+
     @staticmethod
     async def put(
         conn: InMemConnectionProto | Any,
@@ -1253,17 +1421,8 @@ class Threads(Authenticated):
         # This does not accept the auth context since it's only used internally
     ) -> None:
         """Set the status of a thread."""
-        from langgraph_api.serde import json_dumpb, json_loads  # noqa: PLC0415
-
         thread_id = _ensure_uuid(thread_id)
 
-        async def has_pending_runs(conn_: InMemConnectionProto, tid: UUID) -> bool:
-            """Check if thread has any pending runs."""
-            return any(
-                run["status"] in ("pending", "running") and run["thread_id"] == tid
-                for run in conn_.store["runs"]
-            )
-
         # Find the thread
         thread = next(
             (
@@ -1282,47 +1441,15 @@ class Threads(Authenticated):
         if _using_encryption():
             thread = await _decrypt_from_storage(thread, "thread")
 
-        # Determine has_next from checkpoint
-        has_next = False if checkpoint is None else bool(checkpoint["next"])
-
-        # Determine base status
-        if exception:
-            status = "error"
-        elif has_next:
-            status = "interrupted"
-        else:
-            status = "idle"
-
-        # Check for pending runs and update to busy if found
-        if await has_pending_runs(conn, thread_id):
-            status = "busy"
-
-        # Update thread
-        now = datetime.now(UTC)
-        update: dict = {
-            "updated_at": now,
-            "state_updated_at": now,
-            "status": status,
-            "error": json_loads(json_dumpb(exception)) if exception else None,
-        }
-        # Without a checkpoint there is nothing to replace values and interrupts
-        # with, so keep the ones the thread already has.
-        if checkpoint is not None:
-            update["values"] = json_loads(json_dumpb(checkpoint["values"]))
-            update["interrupts"] = json_loads(
-                json_dumpb(
-                    {
-                        t["id"]: [_patch_interrupt(i) for i in t["interrupts"]]
-                        for t in checkpoint["tasks"]
-                        if t.get("interrupts")
-                    }
-                )
-            )
-        thread.update(update)
-        if _using_encryption():
-            encrypted_thread = await _encrypt_for_storage(thread, "thread")
-            stored_thread.clear()
-            stored_thread.update(encrypted_thread)
+        await _save_thread_status(
+            conn,
+            thread_id,
+            thread,
+            stored_thread,
+            checkpoint,
+            exception,
+            datetime.now(UTC),
+        )
 
     @staticmethod
     async def set_joint_status(
@@ -1348,18 +1475,9 @@ class Threads(Authenticated):
             exception: Exception that occurred (affects thread status)
         """
         # No auth since it's internal
-        from langgraph_api.errors import UserInterrupt, UserRollback  # noqa: PLC0415
-        from langgraph_api.serde import json_dumpb, json_loads  # noqa: PLC0415
-
         thread_id = _ensure_uuid(thread_id)
         run_id = _ensure_uuid(run_id)
 
-        def _thread_has_active_runs() -> bool:
-            return any(
-                r["thread_id"] == thread_id and r["status"] in ("pending", "running")
-                for r in conn.store["runs"]
-            )
-
         thread = next(
             (t for t in conn.store["threads"] if t["thread_id"] == thread_id), None
         )
@@ -1380,55 +1498,16 @@ class Threads(Authenticated):
         if run is None:
             raise HTTPException(status_code=404, detail=f"Run {run_id} not found")
 
-        has_next = bool(checkpoint and checkpoint["next"])
-        if exception and not isinstance(exception, UserInterrupt | UserRollback):
-            base_thread_status: ThreadStatus = "error"
-        elif has_next:
-            base_thread_status = "interrupted"
-        else:
-            base_thread_status = "idle"
-
         now = datetime.now(UTC)
 
         if run_status == "rollback":
             await Runs.delete(conn, run_id, thread_id=run["thread_id"])
-            final_thread_status: ThreadStatus = (
-                "busy" if _thread_has_active_runs() else base_thread_status
-            )
-
         else:
             run.update({"status": run_status, "updated_at": now})
-
-            if run_status in ("pending", "running") or _thread_has_active_runs():
-                final_thread_status = "busy"
-            else:
-                final_thread_status = base_thread_status
         thread["metadata"]["graph_id"] = graph_id
-        update: dict = {
-            "updated_at": now,
-            "state_updated_at": now,
-            "status": final_thread_status,
-            "error": json_loads(json_dumpb(exception)) if exception else None,
-        }
-        # Without a checkpoint (a run that ended before writing one, or a
-        # rollback) there is nothing to replace values and interrupts with, so
-        # keep the ones the thread already has.
-        if checkpoint is not None:
-            update["values"] = json_loads(json_dumpb(checkpoint["values"]))
-            update["interrupts"] = json_loads(
-                json_dumpb(
-                    {
-                        t["id"]: [_patch_interrupt(i) for i in t["interrupts"]]
-                        for t in checkpoint["tasks"]
-                        if t.get("interrupts")
-                    }
-                )
-            )
-        thread.update(update)
-        if _using_encryption():
-            encrypted_thread = await _encrypt_for_storage(thread, "thread")
-            stored_thread.clear()
-            stored_thread.update(encrypted_thread)
+        await _save_thread_status(
+            conn, thread_id, thread, stored_thread, checkpoint, exception, now
+        )
 
     @staticmethod
     async def delete(
@@ -1472,6 +1551,8 @@ class Threads(Authenticated):
         for index, candidate in enumerate(thread_list):
             if candidate["thread_id"] == thread_id:
                 thread_list.pop(index)
+                _thread_has_next(conn).pop(thread_id, None)
+                _thread_failed(conn).pop(thread_id, None)
 
                 async def id_iterator() -> AsyncIterator[UUID]:
                     yield thread_id
@@ -1598,7 +1679,10 @@ class Threads(Authenticated):
             ):
                 return _empty_generator()
 
-            # Create new thread with copied metadata
+            # 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.
             now = datetime.now(tz=UTC)
             new_thread: Thread = {
                 "thread_id": new_thread_id,
@@ -1606,16 +1690,29 @@ class Threads(Authenticated):
                 "updated_at": now,
                 "state_updated_at": now,
                 "metadata": copy.deepcopy(original_thread["metadata"]),
-                "status": "idle",
+                "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),
+                ),
                 "config": {},
+                "values": copy.deepcopy(original_thread.get("values")),
+                "interrupts": copy.deepcopy(original_thread.get("interrupts", {})),
+                "error": copy.deepcopy(original_thread.get("error")),
             }
-
             # Add new thread to store
             conn.store["threads"].append(
                 await _encrypt_for_storage(new_thread, "thread")
                 if _using_encryption()
                 else new_thread
             )
+            if thread_id in _thread_has_next(conn):
+                _thread_has_next(conn)[new_thread_id] = _thread_has_next(conn)[
+                    thread_id
+                ]
+            if thread_id in _thread_failed(conn):
+                _thread_failed(conn)[new_thread_id] = _thread_failed(conn)[thread_id]
 
             from langgraph_api import config as api_config  # noqa: PLC0415
 
@@ -2544,10 +2641,7 @@ class Runs(Authenticated):
                     if run["thread_id"] == thread_id
                 ):
                     continue
-                # Increment attempt counter
-                attempt = await conn.retry_counter.increment(run_id)
-                # Set run as "running"
-                run["status"] = "running"
+                stored_run = run
                 encryption_context = None
                 if _using_encryption():
                     from langgraph_runtime_inmem.encryption import (  # noqa: PLC0415
@@ -2558,6 +2652,9 @@ class Runs(Authenticated):
                         run.get("kwargs", {}).get("config")
                     )
                     run = await _decrypt_from_storage(run, "run")
+                # Claim only after decryption succeeds, so failures remain retryable.
+                attempt = await conn.retry_counter.increment(run_id)
+                stored_run["status"] = "running"
                 yield run, attempt, encryption_context
 
     @asynccontextmanager
@@ -2850,6 +2947,7 @@ class Runs(Authenticated):
             created_at=datetime.now(UTC) + timedelta(seconds=after_seconds),
             updated_at=datetime.now(UTC),
             langsmith_session_name=langsmith_session_name,
+            cancel_reason=None,
         )
         stored_run = new_run
         if encryption_enabled:
@@ -3071,6 +3169,7 @@ class Runs(Authenticated):
         stream_manager = get_stream_manager()
         coros = []
         cancelable_runs = []
+        pending_thread_ids: set[UUID] = set()
 
         for run in candidate_runs:
             run_id = run["run_id"]
@@ -3085,20 +3184,11 @@ class Runs(Authenticated):
 
             if run["status"] in ("pending", "running"):
                 cancelable_runs.append(run)
+                if run["status"] == "pending":
+                    pending_thread_ids.add(run["thread_id"])
                 if queues or action != "rollback":
-                    if run["status"] == "pending":
-                        thread = next(
-                            (
-                                t
-                                for t in conn.store["threads"]
-                                if t["thread_id"] == run["thread_id"]
-                            ),
-                            None,
-                        )
-                        if thread:
-                            thread["status"] = "idle"
-                            thread["updated_at"] = datetime.now(tz=UTC)
                     run["status"] = "interrupted"
+                    run["cancel_reason"] = reason
                     run["updated_at"] = datetime.now(tz=UTC)
                 else:
                     await logger.ainfo(
@@ -3126,6 +3216,17 @@ class Runs(Authenticated):
         if coros:
             await asyncio.gather(*coros)
 
+        # Cancelling a pending run changes which runs are active on its thread, so
+        # re-derive the thread's status. Nothing else about the thread changed.
+        if pending_thread_ids:
+            for thread in conn.store["threads"]:
+                if thread["thread_id"] in pending_thread_ids:
+                    thread["status"] = _thread_status(
+                        conn,
+                        thread["thread_id"],
+                    )
+                    thread["updated_at"] = datetime.now(tz=UTC)
+
         await logger.ainfo(
             "Cancelled runs",
             run_ids=[str(r["run_id"]) for r in cancelable_runs],
@@ -3853,7 +3954,15 @@ class Crons(Authenticated):
                 if _using_encryption()
                 else cron
             )
-            yield {**plaintext, "now": now}, encryption_context
+            # The scheduler mutates the payload to build each run; handing out the stored dict breaks every later fire.
+            yield (
+                {
+                    **plaintext,
+                    "payload": copy.deepcopy(plaintext["payload"]),
+                    "now": now,
+                },
+                encryption_context,
+            )
 
     @staticmethod
     async def set_next_run_date(

{langgraph_runtime_inmem-0.37.0.dev2 → langgraph_runtime_inmem-0.37.0.dev4}/uv.lock

@@ -1034,11 +1034,11 @@ wheels = [
 
 [[package]]
 name = "urllib3"
-version = "2.7.0"
+version = "2.8.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e3/05/b17359e1cefb4f909b5e40b1b90a496d987258916dbbf88e842c729f510e/urllib3-2.8.0.tar.gz", hash = "sha256:63bf2ead4c879426ebf22ef2a781eeb4aa3b4ae798a0435506f8687fd5bb9b63", size = 458972, upload-time = "2026-09-15T19:29:36.253Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },
+    { url = "https://files.pythonhosted.org/packages/92/9d/c4e665119135114480843e7ab388fa94d8480650450e6f8e26b70d323a4c/urllib3-2.8.0-py3-none-any.whl", hash = "sha256:0cf3cae568d36aa9576b28dfb35f11328f1cb974ca7647d9475ebb86c75ac6e3", size = 135717, upload-time = "2026-09-15T19:29:34.577Z" },
 ]
 
 [[package]]