langgraph-api 0.2.44__py3-none-any.whl → 0.2.46__py3-none-any.whl

langgraph_api/worker.py

@@ -1,7 +1,7 @@
 import asyncio
 import time
 from collections.abc import AsyncGenerator
-from contextlib import AsyncExitStack, asynccontextmanager
+from contextlib import asynccontextmanager
 from datetime import UTC, datetime
 from typing import TypedDict, cast
 
@@ -20,17 +20,13 @@ from langgraph_api.errors import UserInterrupt, UserRollback
 from langgraph_api.js.errors import RemoteException
 from langgraph_api.metadata import incr_runs
 from langgraph_api.schema import Run
+from langgraph_api.state import state_snapshot_to_thread_state
 from langgraph_api.stream import astream_state, consume
-from langgraph_api.utils import set_auth_ctx, with_user
+from langgraph_api.utils import with_user
 from langgraph_runtime.database import connect
 from langgraph_runtime.ops import Runs, Threads
 from langgraph_runtime.retry import RETRIABLE_EXCEPTIONS
 
-try:
-    from psycopg.errors import InFailedSqlTransaction
-except ImportError:
-    InFailedSqlTransaction = ()
-
 logger = structlog.stdlib.get_logger(__name__)
 
 
@@ -90,45 +86,41 @@ async def worker(
         if request_created_at is not None
         else None
     )
-    async with (
-        connect() as conn,
-        set_auth_ctx_for_run(run["kwargs"]),
-        Runs.enter(run_id, main_loop) as done,
-        AsyncExitStack() as exit_stack,
-    ):
-        temporary = run["kwargs"].get("temporary", False)
-        resumable = run["kwargs"].get("resumable", False)
-        run_created_at = run["created_at"].isoformat()
-        lg_logging.set_logging_context(
-            {
-                "run_id": str(run_id),
-                "run_attempt": attempt,
-                "thread_id": str(run.get("thread_id")),
-                "assistant_id": str(run.get("assistant_id")),
-                "graph_id": _get_graph_id(run),
-                "request_id": _get_request_id(run),
-            }
-        )
-        run_stream_started_at = datetime.now(UTC)
-        await logger.ainfo(
-            "Starting background run",
-            run_started_at=run_started_at.isoformat(),
-            run_creation_ms=run_creation_ms,
-            run_queue_ms=ms(run_started_at, run["created_at"]),
-            run_stream_start_ms=ms(run_stream_started_at, run_started_at),
-        )
+    temporary = run["kwargs"].get("temporary", False)
+    resumable = run["kwargs"].get("resumable", False)
+    run_created_at = run["created_at"].isoformat()
+    lg_logging.set_logging_context(
+        {
+            "run_id": str(run_id),
+            "run_attempt": attempt,
+            "thread_id": str(run.get("thread_id")),
+            "assistant_id": str(run.get("assistant_id")),
+            "graph_id": _get_graph_id(run),
+            "request_id": _get_request_id(run),
+        }
+    )
+    run_stream_started_at = datetime.now(UTC)
+    await logger.ainfo(
+        "Starting background run",
+        run_started_at=run_started_at.isoformat(),
+        run_creation_ms=run_creation_ms,
+        run_queue_ms=ms(run_started_at, run["created_at"]),
+        run_stream_start_ms=ms(run_stream_started_at, run_started_at),
+    )
 
-        def on_checkpoint(checkpoint_arg: CheckpointPayload):
-            nonlocal checkpoint
-            checkpoint = checkpoint_arg
+    def on_checkpoint(checkpoint_arg: CheckpointPayload):
+        nonlocal checkpoint
+        checkpoint = checkpoint_arg
 
-        def on_task_result(task_result: TaskResultPayload):
-            if checkpoint is not None:
-                for task in checkpoint["tasks"]:
-                    if task["id"] == task_result["id"]:
-                        task.update(task_result)
-                        break
+    def on_task_result(task_result: TaskResultPayload):
+        if checkpoint is not None:
+            for task in checkpoint["tasks"]:
+                if task["id"] == task_result["id"]:
+                    task.update(task_result)
+                    break
 
+    async with Runs.enter(run_id, main_loop) as done:
+        # attempt the run
         try:
             if attempt > BG_JOB_MAX_RETRIES:
                 await logger.aerror(
@@ -155,70 +147,25 @@ async def worker(
                     )
 
                 raise RuntimeError(error_message)
-            if temporary:
-                stream = astream_state(exit_stack, conn, cast(Run, run), attempt, done)
-            else:
-                stream = astream_state(
-                    exit_stack,
-                    conn,
-                    cast(Run, run),
-                    attempt,
-                    done,
-                    on_checkpoint=on_checkpoint,
-                    on_task_result=on_task_result,
+            async with set_auth_ctx_for_run(run["kwargs"]):
+                if temporary:
+                    stream = astream_state(cast(Run, run), attempt, done)
+                else:
+                    stream = astream_state(
+                        cast(Run, run),
+                        attempt,
+                        done,
+                        on_checkpoint=on_checkpoint,
+                        on_task_result=on_task_result,
+                    )
+                await asyncio.wait_for(
+                    consume(stream, run_id, resumable),
+                    BG_JOB_TIMEOUT_SECS,
                 )
-            await asyncio.wait_for(
-                consume(stream, run_id, resumable),
-                BG_JOB_TIMEOUT_SECS,
-            )
-            run_ended_at_dt = datetime.now(UTC)
-            run_ended_at = run_ended_at_dt.isoformat()
-            await logger.ainfo(
-                "Background run succeeded",
-                run_id=str(run_id),
-                run_attempt=attempt,
-                run_created_at=run_created_at,
-                run_started_at=run_started_at.isoformat(),
-                run_ended_at=run_ended_at,
-                run_exec_ms=ms(run_ended_at_dt, run_started_at),
-                run_completed_in_ms=(
-                    int((run_ended_at_dt.timestamp() * 1_000) - request_created_at)
-                    if request_created_at is not None
-                    else None
-                ),
-            )
-            status = "success"
-            await Runs.set_status(conn, run_id, "success")
-        except TimeoutError as e:
-            exception = e
-            status = "timeout"
-            run_ended_at = datetime.now(UTC).isoformat()
-            await logger.awarning(
-                "Background run timed out",
-                run_id=str(run_id),
-                run_attempt=attempt,
-                run_created_at=run_created_at,
-                run_started_at=run_started_at.isoformat(),
-                run_ended_at=run_ended_at,
-                run_exec_ms=ms(datetime.now(UTC), run_started_at),
-                run_completed_in_ms=(
-                    int((run_ended_at_dt.timestamp() * 1_000) - request_created_at)
-                    if request_created_at is not None
-                    else None
-                ),
-            )
-            await Runs.set_status(conn, run_id, "timeout")
-        except UserRollback as e:
-            exception = e
-            status = "rollback"
-            run_ended_at_dt = datetime.now(UTC)
-            run_ended_at = run_ended_at_dt.isoformat()
-            try:
-                # Need to close the pipeline to re-use the connection
-                await exit_stack.aclose()
-                await Runs.delete(conn, run_id, thread_id=run["thread_id"])
+                run_ended_at_dt = datetime.now(UTC)
+                run_ended_at = run_ended_at_dt.isoformat()
                 await logger.ainfo(
-                    "Background run rolled back",
+                    "Background run succeeded",
                     run_id=str(run_id),
                     run_attempt=attempt,
                     run_created_at=run_created_at,
@@ -231,118 +178,163 @@ async def worker(
                         else None
                     ),
                 )
+        except Exception as ee:
+            # Note we don't handle asyncio.CancelledError here, as we want to
+            # let it bubble up and rollback db transaction, thus marking the run
+            # as available to be picked up by another worker
+            exception = ee
 
-            except InFailedSqlTransaction as e:
-                await logger.ainfo(
-                    "Ignoring rollback error",
+        # handle exceptions and set status
+        async with connect() as conn:
+            if exception is None:
+                status = "success"
+                await Runs.set_status(conn, run_id, "success")
+                # If a stateful run succeeded but no checkpoint was returned, likely
+                # there was a retriable exception that resumed right at the end
+                if checkpoint is None and not temporary:
+                    await logger.ainfo(
+                        "Fetching missing checkpoint for webhook",
+                        run_id=str(run_id),
+                        run_attempt=attempt,
+                    )
+                    try:
+                        state_snapshot = await Threads.State.get(
+                            conn, run["kwargs"]["config"]
+                        )
+                        checkpoint = state_snapshot_to_thread_state(state_snapshot)
+                    except Exception:
+                        await logger.aerror(
+                            "Failed to fetch missing checkpoint for webhook. Continuing...",
+                            exc_info=True,
+                            run_id=str(run_id),
+                            run_attempt=attempt,
+                        )
+            elif isinstance(exception, TimeoutError):
+                status = "timeout"
+                run_ended_at = datetime.now(UTC).isoformat()
+                await logger.awarning(
+                    "Background run timed out",
                     run_id=str(run_id),
                     run_attempt=attempt,
                     run_created_at=run_created_at,
-                    exc=str(e),
+                    run_started_at=run_started_at.isoformat(),
+                    run_ended_at=run_ended_at,
+                    run_exec_ms=ms(datetime.now(UTC), run_started_at),
+                    run_completed_in_ms=(
+                        int((run_ended_at_dt.timestamp() * 1_000) - request_created_at)
+                        if request_created_at is not None
+                        else None
+                    ),
                 )
-            except HTTPException as e:
-                if e.status_code == 404:
+                await Runs.set_status(conn, run_id, "timeout")
+            elif isinstance(exception, UserRollback):
+                status = "rollback"
+                run_ended_at_dt = datetime.now(UTC)
+                run_ended_at = run_ended_at_dt.isoformat()
+                try:
+                    await Runs.delete(conn, run_id, thread_id=run["thread_id"])
                     await logger.ainfo(
-                        "Ignoring rollback error for missing run",
+                        "Background run rolled back",
                         run_id=str(run_id),
                         run_attempt=attempt,
                         run_created_at=run_created_at,
+                        run_started_at=run_started_at.isoformat(),
+                        run_ended_at=run_ended_at,
+                        run_exec_ms=ms(run_ended_at_dt, run_started_at),
+                        run_completed_in_ms=(
+                            int(
+                                (run_ended_at_dt.timestamp() * 1_000)
+                                - request_created_at
+                            )
+                            if request_created_at is not None
+                            else None
+                        ),
                     )
-                else:
-                    raise
+                except HTTPException as e:
+                    if e.status_code == 404:
+                        await logger.ainfo(
+                            "Ignoring rollback error for missing run",
+                            run_id=str(run_id),
+                            run_attempt=attempt,
+                            run_created_at=run_created_at,
+                        )
+                    else:
+                        raise
 
-            checkpoint = None  # reset the checkpoint
-        except UserInterrupt as e:
-            exception = e
-            status = "interrupted"
-            run_ended_at_dt = datetime.now(UTC)
-            run_ended_at = run_ended_at_dt.isoformat()
-            await logger.ainfo(
-                "Background run interrupted",
-                run_id=str(run_id),
-                run_attempt=attempt,
-                run_created_at=run_created_at,
-                run_started_at=run_started_at.isoformat(),
-                run_ended_at=run_ended_at,
-                run_exec_ms=ms(run_ended_at_dt, run_started_at),
-                run_completed_in_ms=(
-                    int((run_ended_at_dt.timestamp() * 1_000) - request_created_at)
-                    if request_created_at is not None
-                    else None
-                ),
-            )
-            await Runs.set_status(conn, run_id, "interrupted")
-        except RETRIABLE_EXCEPTIONS as e:
-            exception = e
-            status = "retry"
-            run_ended_at_dt = datetime.now(UTC)
-            run_ended_at = run_ended_at_dt.isoformat()
-            await logger.awarning(
-                f"Background run failed, will retry. Exception: {e}",
-                exc_info=True,
-                run_id=str(run_id),
-                run_attempt=attempt,
-                run_created_at=run_created_at,
-                run_started_at=run_started_at.isoformat(),
-                run_ended_at=run_ended_at,
-                run_exec_ms=ms(run_ended_at_dt, run_started_at),
-            )
-            await Runs.set_status(conn, run_id, "pending")
-            raise
-        except Exception as exc:
-            exception = exc
-            status = "error"
-            run_ended_at_dt = datetime.now(UTC)
-            run_ended_at = run_ended_at_dt.isoformat()
-            await logger.aexception(
-                f"Background run failed. Exception: {exc}",
-                exc_info=not isinstance(exc, RemoteException),
-                run_id=str(run_id),
-                run_attempt=attempt,
-                run_created_at=run_created_at,
-                run_started_at=run_started_at.isoformat(),
-                run_ended_at=run_ended_at,
-                run_exec_ms=ms(run_ended_at_dt, run_started_at),
-            )
-            await Runs.set_status(conn, run_id, "error")
-        set_auth_ctx(None, None)
-        # delete or set status of thread
-        if temporary:
-            await Threads.delete(conn, run["thread_id"])
-        else:
-            try:
-                await Threads.set_status(conn, run["thread_id"], checkpoint, exception)
-            except HTTPException as e:
-                if e.status_code == 404:
-                    await logger.ainfo(
-                        "Ignoring set_status error for missing thread", exc=str(e)
-                    )
+                checkpoint = None  # reset the checkpoint
+            elif isinstance(exception, UserInterrupt):
+                status = "interrupted"
+                run_ended_at_dt = datetime.now(UTC)
+                run_ended_at = run_ended_at_dt.isoformat()
+                await logger.ainfo(
+                    "Background run interrupted",
+                    run_id=str(run_id),
+                    run_attempt=attempt,
+                    run_created_at=run_created_at,
+                    run_started_at=run_started_at.isoformat(),
+                    run_ended_at=run_ended_at,
+                    run_exec_ms=ms(run_ended_at_dt, run_started_at),
+                    run_completed_in_ms=(
+                        int((run_ended_at_dt.timestamp() * 1_000) - request_created_at)
+                        if request_created_at is not None
+                        else None
+                    ),
+                )
+                await Runs.set_status(conn, run_id, "interrupted")
+            elif isinstance(exception, RETRIABLE_EXCEPTIONS):
+                status = "retry"
+                run_ended_at_dt = datetime.now(UTC)
+                run_ended_at = run_ended_at_dt.isoformat()
+                await logger.awarning(
+                    f"Background run failed, will retry. Exception: {exception}",
+                    exc_info=True,
+                    run_id=str(run_id),
+                    run_attempt=attempt,
+                    run_created_at=run_created_at,
+                    run_started_at=run_started_at.isoformat(),
+                    run_ended_at=run_ended_at,
+                    run_exec_ms=ms(run_ended_at_dt, run_started_at),
+                )
+                await Runs.set_status(conn, run_id, "pending")
+            else:
+                status = "error"
+                run_ended_at_dt = datetime.now(UTC)
+                run_ended_at = run_ended_at_dt.isoformat()
+                await logger.aexception(
+                    f"Background run failed. Exception: {exception}",
+                    exc_info=not isinstance(exception, RemoteException),
+                    run_id=str(run_id),
+                    run_attempt=attempt,
+                    run_created_at=run_created_at,
+                    run_started_at=run_started_at.isoformat(),
+                    run_ended_at=run_ended_at,
+                    run_exec_ms=ms(run_ended_at_dt, run_started_at),
+                )
+                await Runs.set_status(conn, run_id, "error")
+
+            # delete or set status of thread
+            if not isinstance(exception, RETRIABLE_EXCEPTIONS):
+                if temporary:
+                    await Threads.delete(conn, run["thread_id"])
                 else:
-                    raise
-        # Note we don't handle asyncio.CancelledError here, as we want to
-        # let it bubble up and rollback db transaction, thus marking the run
-        # as available to be picked up by another worker
+                    try:
+                        await Threads.set_status(
+                            conn, run["thread_id"], checkpoint, exception
+                        )
+                    except HTTPException as e:
+                        if e.status_code == 404:
+                            await logger.ainfo(
+                                "Ignoring set_status error for missing thread",
+                                exc=str(e),
+                            )
+                        else:
+                            raise
 
-    # If a stateful run succeeded but no checkoint was returned, it's likely because
-    # there was a retriable exception that resumed right at the end
-    if checkpoint is None and (not temporary) and webhook and status == "success":
-        await logger.ainfo(
-            "Fetching missing checkpoint for webhook",
-            run_id=str(run_id),
-            run_attempt=attempt,
-        )
-        try:
-            state_snapshot = await Threads.State.get(
-                conn, run["kwargs"]["config"], subgraphs=True
-            )
-            checkpoint = {"values": state_snapshot.values}
-        except Exception:
-            await logger.aerror(
-                "Failed to fetch missing checkpoint for webhook. Continuing...",
-                exc_info=True,
-                run_id=str(run_id),
-                run_attempt=attempt,
-            )
+        if isinstance(exception, RETRIABLE_EXCEPTIONS):
+            # re-raise so Runs.enter knows not to mark as done
+            # Runs.enter will catch the exception, but what triggers the retry
+            # is setting the status to "pending"
+            raise exception
 
     return WorkerResult(
         checkpoint=checkpoint,

{langgraph_api-0.2.44.dist-info → langgraph_api-0.2.46.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.2.44
+Version: 0.2.46
 Author-email: Nuno Campos <nuno@langchain.dev>, Will Fu-Hinthorn <will@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE
@@ -9,12 +9,12 @@ Requires-Dist: cloudpickle>=3.0.0
 Requires-Dist: cryptography<45.0,>=42.0.0
 Requires-Dist: httpx>=0.25.0
 Requires-Dist: jsonschema-rs<0.30,>=0.20.0
-Requires-Dist: langchain-core>=0.2.38
+Requires-Dist: langchain-core>=0.3.64
 Requires-Dist: langgraph-checkpoint>=2.0.23
 Requires-Dist: langgraph-runtime-inmem<0.3,>=0.2.0
 Requires-Dist: langgraph-sdk>=0.1.66
 Requires-Dist: langgraph>=0.3.27
-Requires-Dist: langsmith>=0.1.112
+Requires-Dist: langsmith>=0.3.45
 Requires-Dist: orjson>=3.9.7
 Requires-Dist: pyjwt>=2.9.0
 Requires-Dist: sse-starlette<2.2.0,>=2.1.0

{langgraph_api-0.2.44.dist-info → langgraph_api-0.2.46.dist-info}/RECORD

@@ -1,4 +1,4 @@
-langgraph_api/__init__.py,sha256=U9IXTG0wwP5qkavLVbDEmAfwEJjO-1-R5e__z2cNpz0,23
+langgraph_api/__init__.py,sha256=UXWRy3OxZgq8UtpnFH0qpST_16fmfqlmJEOi5Y-OrzI,23
 langgraph_api/asgi_transport.py,sha256=eqifhHxNnxvI7jJqrY1_8RjL4Fp9NdN4prEub2FWBt8,5091
 langgraph_api/asyncio.py,sha256=nelZwKL7iOjM5GHj1rVjiPE7igUIKLNKtc-3urxmlfo,9250
 langgraph_api/cli.py,sha256=9Ou3tGDDY_VVLt5DFle8UviJdpI4ZigC5hElYvq2-To,14519
@@ -8,7 +8,7 @@ langgraph_api/cron_scheduler.py,sha256=i87j4pJrcsmsqMKeKUs69gaAjrGaSM3pM3jnXdN5J
 langgraph_api/errors.py,sha256=Bu_i5drgNTyJcLiyrwVE_6-XrSU50BHf9TDpttki9wQ,1690
 langgraph_api/graph.py,sha256=MPm8DvInBQsq2em45c2YD5bW6T_G1LlDkAuWq-19gCQ,23240
 langgraph_api/http.py,sha256=gYbxxjY8aLnsXeJymcJ7G7Nj_yToOGpPYQqmZ1_ggfA,5240
-langgraph_api/logging.py,sha256=bx6kxV7O2FUnu0ubrgeJuj5q2EjYC4ve1BkbrVfzy28,3953
+langgraph_api/logging.py,sha256=1BXELwUBY8gZeOWCYElbBu_GyHLM2jjlDVJznlekqvQ,4268
 langgraph_api/metadata.py,sha256=2sz9ECnbnQtgqN6ptDkRmymaVKfQPgaX-JuDJDJB47c,4254
 langgraph_api/patch.py,sha256=Dgs0PXHytekX4SUL6KsjjN0hHcOtGLvv1GRGbh6PswU,1408
 langgraph_api/queue_entrypoint.py,sha256=_41ZveMDdn9bapjA7Ik9FG3r4hyIwXESUM5F1PdlieE,2309
@@ -19,18 +19,18 @@ langgraph_api/server.py,sha256=Z_VL-kIphybTRDWBIqHMfRhgCmAFyTRqAGlgnHQF0Zg,6973
 langgraph_api/sse.py,sha256=F7swfjKBDrlUmXZ_dWuDVHtp-3o1Cpjq1lwp0bJD-nw,4223
 langgraph_api/state.py,sha256=8jx4IoTCOjTJuwzuXJKKFwo1VseHjNnw_CCq4x1SW14,2284
 langgraph_api/store.py,sha256=_xGhdwEIMoY1_hIy_oWwxZp4Y7FH833BNJfgFIhT80E,4640
-langgraph_api/stream.py,sha256=0qLblAQ406bGZEM1zRQKVyU407c9PjcBcgPCKN78ywc,12847
+langgraph_api/stream.py,sha256=Rb9mIeG7nnGtKJhImzkNlE3c0g6C0yM6bbYXQs5GOHU,13560
 langgraph_api/thread_ttl.py,sha256=-Ox8NFHqUH3wGNdEKMIfAXUubY5WGifIgCaJ7npqLgw,1762
 langgraph_api/utils.py,sha256=92mSti9GfGdMRRWyESKQW5yV-75Z9icGHnIrBYvdypU,3619
 langgraph_api/validation.py,sha256=zMuKmwUEBjBgFMwAaeLZmatwGVijKv2sOYtYg7gfRtc,4950
 langgraph_api/webhook.py,sha256=1ncwO0rIZcj-Df9sxSnFEzd1gP1bfS4okeZQS8NSRoE,1382
-langgraph_api/worker.py,sha256=YjMadekwt8t7Mn-pxZe8H-SJfetT31bl3MO2WFGVzBg,14510
+langgraph_api/worker.py,sha256=CWXSc4LHQLtNPJgCJC2khw6jb3DNKXnqQ4oB8-UyNSY,15163
 langgraph_api/api/__init__.py,sha256=YVzpbn5IQotvuuLG9fhS9QMrxXfP4s4EpEMG0n4q3Nw,5625
-langgraph_api/api/assistants.py,sha256=x_V1rnSGFYjNZFJkZKFN9yNFOqXhqkOSqMDSv3I8VeE,15880
+langgraph_api/api/assistants.py,sha256=6IPVKQBlI95-Z4nYdqBY9st9oynGJAocL67cwnDaZCk,15744
 langgraph_api/api/mcp.py,sha256=RvRYgANqRzNQzSmgjNkq4RlKTtoEJYil04ot9lsmEtE,14352
 langgraph_api/api/meta.py,sha256=S6vj9lvVlZhRYDyefFtJMlqYTPxfYGC5EQKD5hx8Kp8,2946
 langgraph_api/api/openapi.py,sha256=362m6Ny8wOwZ6HrDK9JAVUzPkyLYWKeV1E71hPOaA0U,11278
-langgraph_api/api/runs.py,sha256=wD7Z8c7qdPCtlvzE6GxxaB3ajP0iSfn86-La-jmaWtc,19214
+langgraph_api/api/runs.py,sha256=9jU9C4myBhgZXyvR9MzNn9KrpNo7DvWbg8uNeWzSmKE,19524
 langgraph_api/api/store.py,sha256=TSeMiuMfrifmEnEbL0aObC2DPeseLlmZvAMaMzPgG3Y,5535
 langgraph_api/api/threads.py,sha256=ogMKmEoiycuaV3fa5kpupDohJ7fwUOfVczt6-WSK4FE,9322
 langgraph_api/api/ui.py,sha256=2nlipYV2nUGR4T9pceaAbgN1lS3-T2zPBh7Nv3j9eZQ,2479
@@ -52,7 +52,7 @@ langgraph_api/js/client.mts,sha256=N9CTH7mbXGSD-gpv-XyruYsHI-rgrObL8cQoAp5s3_U,3
 langgraph_api/js/errors.py,sha256=Cm1TKWlUCwZReDC5AQ6SgNIVGD27Qov2xcgHyf8-GXo,361
 langgraph_api/js/global.d.ts,sha256=j4GhgtQSZ5_cHzjSPcHgMJ8tfBThxrH-pUOrrJGteOU,196
 langgraph_api/js/package.json,sha256=7_qkj-b0_bpHFFyBDgGaZl3BeuSqkbCD7wNn-ZvQeGA,1333
-langgraph_api/js/remote.py,sha256=utq7tjSFUf0zPLDFgC9lnsGKrtX3EVEX6IcNCc9Q1yM,35934
+langgraph_api/js/remote.py,sha256=TwEpmUm6bTLnH8Ku4zCP3cCHyNrYJMIFs4TRUHQTI8Y,35796
 langgraph_api/js/schema.py,sha256=7idnv7URlYUdSNMBXQcw7E4SxaPxCq_Oxwnlml8q5ik,408
 langgraph_api/js/sse.py,sha256=lsfp4nyJyA1COmlKG9e2gJnTttf_HGCB5wyH8OZBER8,4105
 langgraph_api/js/tsconfig.json,sha256=imCYqVnqFpaBoZPx8k1nO4slHIWBFsSlmCYhO73cpBs,341
@@ -70,16 +70,24 @@ langgraph_api/middleware/http_logger.py,sha256=aj4mdisRobFePkD3Iy6-w_Mujwx4TQRaE
 langgraph_api/middleware/private_network.py,sha256=eYgdyU8AzU2XJu362i1L8aSFoQRiV7_aLBPw7_EgeqI,2111
 langgraph_api/middleware/request_id.py,sha256=fmtp0jLqoSqXTD39d9PW7jVlIvGqGurqgteMCeexRvY,1106
 langgraph_api/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/models/run.py,sha256=orI907khq8SNOJAtGed-jgMThCMzqheIZcuFT9I1_VA,14040
+langgraph_api/models/run.py,sha256=j1s9KRfFXgjKUudB9z7IVJ34Klo85PPeaVFtmWHhEdo,14514
 langgraph_api/tunneling/cloudflare.py,sha256=iKb6tj-VWPlDchHFjuQyep2Dpb-w2NGfJKt-WJG9LH0,3650
 langgraph_license/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_license/validation.py,sha256=ZKraAVJArAABKqrmHN-EN18ncoNUmRm500Yt1Sc7tUA,537
 langgraph_runtime/__init__.py,sha256=O4GgSmu33c-Pr8Xzxj_brcK5vkm70iNTcyxEjICFZxA,1075
+langgraph_runtime/checkpoint.py,sha256=J2ePryEyKJWGgxjs27qEHrjj87uPMX3Rqm3hLvG63uk,119
+langgraph_runtime/database.py,sha256=ANEtfm4psr19FtpVcNs5CFWHw-JhfHvIMnkaORa4QSM,117
+langgraph_runtime/lifespan.py,sha256=-YIHyEEaP_F2tSdTP0tNjfAJXs7KfxaIsWdmQAUi2KM,117
+langgraph_runtime/metrics.py,sha256=CIBw3tjTg1c-o3_2InA-qV34028fQcYWBYkpN6zdEoI,116
+langgraph_runtime/ops.py,sha256=ht_U9LPbHWy0l95b_Q0Vvtd7kYxeZsaSKSf0WpwHUoo,112
+langgraph_runtime/queue.py,sha256=m7req6Ca9NOw1yp-zo30zGhldRWDFk4QVL_tgrVrhQg,114
+langgraph_runtime/retry.py,sha256=V0duD01fO7GUQ_btQkp1aoXcEOFhXooGVP6q4yMfuyY,114
+langgraph_runtime/store.py,sha256=7mowndlsIroGHv3NpTSOZDJR0lCuaYMBoTnTrewjslw,114
 LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
 logging.json,sha256=3RNjSADZmDq38eHePMm1CbP6qZ71AmpBtLwCmKU9Zgo,379
-openapi.json,sha256=_4GFDqbq1X9vD4_FxwahuVODJMOHx-U76gkY4rdy3DA,138189
-langgraph_api-0.2.44.dist-info/METADATA,sha256=9OXLai4MqakDiva3wfVGk3vmX4akdCJ1zKuvNpl62t4,3892
-langgraph_api-0.2.44.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langgraph_api-0.2.44.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
-langgraph_api-0.2.44.dist-info/licenses/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
-langgraph_api-0.2.44.dist-info/RECORD,,
+openapi.json,sha256=RDaC5RO3ypsQubo6SeNxXys7cLtC0-1WY5LXZ6P-Ak4,141659
+langgraph_api-0.2.46.dist-info/METADATA,sha256=oU8b8_iGeOqDDk2CkTTfL0zaQQ0PJrKWsShXi6xIFfE,3891
+langgraph_api-0.2.46.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langgraph_api-0.2.46.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
+langgraph_api-0.2.46.dist-info/licenses/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
+langgraph_api-0.2.46.dist-info/RECORD,,

langgraph_runtime/checkpoint.py

@@ -0,0 +1,4 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from langgraph_runtime_inmem.checkpoint import *  # noqa: F403

langgraph_runtime/database.py

@@ -0,0 +1,4 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from langgraph_runtime_inmem.database import *  # noqa: F403

langgraph_runtime/lifespan.py

@@ -0,0 +1,4 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from langgraph_runtime_inmem.lifespan import *  # noqa: F403

langgraph_runtime/metrics.py

@@ -0,0 +1,4 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from langgraph_runtime_inmem.metrics import *  # noqa: F403

langgraph_runtime/ops.py

@@ -0,0 +1,4 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from langgraph_runtime_inmem.ops import *  # noqa: F403

langgraph_runtime/queue.py

@@ -0,0 +1,4 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from langgraph_runtime_inmem.queue import *  # noqa: F403

langgraph_runtime/retry.py

@@ -0,0 +1,4 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from langgraph_runtime_inmem.retry import *  # noqa: F403

langgraph_runtime/store.py

@@ -0,0 +1,4 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from langgraph_runtime_inmem.store import *  # noqa: F403