langgraph-api 0.0.31__py3-none-any.whl → 0.0.33__py3-none-any.whl

langgraph_api/graph.py

@@ -21,6 +21,7 @@ from langgraph.pregel import Pregel
 from langgraph.store.base import BaseStore
 from starlette.exceptions import HTTPException
 
+from langgraph_api import asyncio as lg_asyncio
 from langgraph_api.js.base import BaseRemotePregel
 from langgraph_api.schema import Config
 
@@ -60,6 +61,12 @@ async def register_graph(graph_id: str, graph: GraphValue, config: dict | None)
         )
 
 
+def register_graph_sync(
+    graph_id: str, graph: GraphValue, config: dict | None = None
+) -> None:
+    lg_asyncio.run_coroutine_threadsafe(register_graph(graph_id, graph, config))
+
+
 @asynccontextmanager
 async def _generate_graph(value: Any) -> AsyncIterator[Any]:
     """Yield a graph object regardless of its type."""
@@ -187,24 +194,33 @@ async def collect_graphs_from_env(register: bool = False) -> None:
     config_per_graph = _load_graph_config_from_env() or {}
 
     if paths_str:
-        specs = [
-            (
+        specs = []
+        for key, value in json.loads(paths_str).items():
+            try:
+                path_or_module, variable = value.rsplit(":", maxsplit=1)
+            except ValueError as e:
+                raise ValueError(
+                    f"Invalid path '{value}' for graph '{key}'."
+                    " Did you miss a variable name?\n"
+                    " Expected one of the following formats:"
+                    " 'my.module:variable_name' or '/path/to/file.py:variable_name'"
+                ) from e
+            specs.append(
                 GraphSpec(
                     key,
-                    module=value.split(":")[0],
-                    variable=value.split(":")[1],
+                    module=path_or_module,
+                    variable=variable,
                     config=config_per_graph.get(key),
                 )
                 if "/" not in value
                 else GraphSpec(
                     key,
-                    path=value.split(":")[0],
-                    variable=value.split(":")[1],
+                    path=path_or_module,
+                    variable=variable,
                     config=config_per_graph.get(key),
                 )
             )
-            for key, value in json.loads(paths_str).items()
-        ]
+
     else:
         specs = [
             GraphSpec(

langgraph_api/js/remote.py

@@ -1,8 +1,10 @@
 import asyncio
+import logging
 import os
 import shutil
 import ssl
 from collections.abc import AsyncIterator
+from contextlib import AbstractContextManager
 from typing import Any, Literal
 
 import certifi
@@ -605,60 +607,79 @@ async def run_remote_checkpointer():
     await server.serve()
 
 
+class DisableHttpxLoggingContextManager(AbstractContextManager):
+    """
+    Disable HTTP/1.1 200 OK logs spamming stdout.
+    """
+
+    filter: logging.Filter
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        return "200 OK" not in record.getMessage()
+
+    def __enter__(self):
+        logging.getLogger("httpx").addFilter(self.filter)
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        logging.getLogger("httpx").removeFilter(self.filter)
+
+
 async def wait_until_js_ready():
-    async with (
-        httpx.AsyncClient(
-            base_url=f"http://localhost:{GRAPH_PORT}",
-            limits=httpx.Limits(max_connections=1),
-            transport=httpx.AsyncHTTPTransport(verify=SSL),
-        ) as graph_client,
-        httpx.AsyncClient(
-            base_url=f"http://localhost:{REMOTE_PORT}",
-            limits=httpx.Limits(max_connections=1),
-            transport=httpx.AsyncHTTPTransport(verify=SSL),
-        ) as checkpointer_client,
-    ):
-        attempt = 0
-        while not asyncio.current_task().cancelled():
+    with DisableHttpxLoggingContextManager():
+        async with (
+            httpx.AsyncClient(
+                base_url=f"http://localhost:{GRAPH_PORT}",
+                limits=httpx.Limits(max_connections=1),
+                transport=httpx.AsyncHTTPTransport(verify=SSL),
+            ) as graph_client,
+            httpx.AsyncClient(
+                base_url=f"http://localhost:{REMOTE_PORT}",
+                limits=httpx.Limits(max_connections=1),
+                transport=httpx.AsyncHTTPTransport(verify=SSL),
+            ) as checkpointer_client,
+        ):
+            attempt = 0
+            while not asyncio.current_task().cancelled():
+                try:
+                    res = await graph_client.get("/ok")
+                    res.raise_for_status()
+                    res = await checkpointer_client.get("/ok")
+                    res.raise_for_status()
+                    return
+                except httpx.HTTPError:
+                    if attempt > 240:
+                        raise
+                    else:
+                        attempt += 1
+                        await asyncio.sleep(0.5)
+
+
+async def js_healthcheck():
+    with DisableHttpxLoggingContextManager():
+        async with (
+            httpx.AsyncClient(
+                base_url=f"http://localhost:{GRAPH_PORT}",
+                limits=httpx.Limits(max_connections=1),
+                transport=httpx.AsyncHTTPTransport(verify=SSL),
+            ) as graph_client,
+            httpx.AsyncClient(
+                base_url=f"http://localhost:{REMOTE_PORT}",
+                limits=httpx.Limits(max_connections=1),
+                transport=httpx.AsyncHTTPTransport(verify=SSL),
+            ) as checkpointer_client,
+        ):
             try:
                 res = await graph_client.get("/ok")
                 res.raise_for_status()
                 res = await checkpointer_client.get("/ok")
                 res.raise_for_status()
-                return
-            except httpx.HTTPError:
-                if attempt > 240:
-                    raise
-                else:
-                    attempt += 1
-                    await asyncio.sleep(0.5)
-
-
-async def js_healthcheck():
-    async with (
-        httpx.AsyncClient(
-            base_url=f"http://localhost:{GRAPH_PORT}",
-            limits=httpx.Limits(max_connections=1),
-            transport=httpx.AsyncHTTPTransport(verify=SSL),
-        ) as graph_client,
-        httpx.AsyncClient(
-            base_url=f"http://localhost:{REMOTE_PORT}",
-            limits=httpx.Limits(max_connections=1),
-            transport=httpx.AsyncHTTPTransport(verify=SSL),
-        ) as checkpointer_client,
-    ):
-        try:
-            res = await graph_client.get("/ok")
-            res.raise_for_status()
-            res = await checkpointer_client.get("/ok")
-            res.raise_for_status()
-            return True
-        except httpx.HTTPError as exc:
-            logger.warning(
-                "JS healthcheck failed. Either the JS server is not running or the event loop is blocked by a CPU-intensive task.",
-                error=exc,
-            )
-            raise HTTPException(
-                status_code=500,
-                detail="JS healthcheck failed. Either the JS server is not running or the event loop is blocked by a CPU-intensive task.",
-            ) from exc
+                return True
+            except httpx.HTTPError as exc:
+                logger.warning(
+                    "JS healthcheck failed. Either the JS server is not running or the event loop is blocked by a CPU-intensive task.",
+                    error=exc,
+                )
+                raise HTTPException(
+                    status_code=500,
+                    detail="JS healthcheck failed. Either the JS server is not running or the event loop is blocked by a CPU-intensive task.",
+                ) from exc

langgraph_api/lifespan.py

@@ -1,10 +1,11 @@
 import asyncio
 from contextlib import asynccontextmanager
 
+import structlog
 from starlette.applications import Starlette
 
 import langgraph_api.config as config
-from langgraph_api.asyncio import SimpleTaskGroup
+from langgraph_api.asyncio import SimpleTaskGroup, set_event_loop
 from langgraph_api.cron_scheduler import cron_scheduler
 from langgraph_api.graph import collect_graphs_from_env, stop_remote_graphs
 from langgraph_api.http import start_http_client, stop_http_client
@@ -14,6 +15,8 @@ from langgraph_storage.database import start_pool, stop_pool
 from langgraph_storage.queue import queue
 from langgraph_storage.store import Store
 
+logger = structlog.stdlib.get_logger(__name__)
+
 
 @asynccontextmanager
 async def lifespan(
@@ -21,6 +24,12 @@ async def lifespan(
     with_cron_scheduler: bool = True,
     taskset: set[asyncio.Task] | None = None,
 ):
+    try:
+        current_loop = asyncio.get_running_loop()
+        set_event_loop(current_loop)
+    except RuntimeError:
+        await logger.aerror("Failed to set loop")
+
     if not await get_license_status():
         raise ValueError(
             "License verification failed. Please ensure proper configuration:\n"

langgraph_api/logging.py

@@ -119,13 +119,14 @@ class Formatter(structlog.stdlib.ProcessorFormatter):
 
 # configure structlog
 
-structlog.configure(
-    processors=[
-        structlog.stdlib.filter_by_level,
-        *shared_processors,
-        structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
-    ],
-    logger_factory=structlog.stdlib.LoggerFactory(),
-    wrapper_class=structlog.stdlib.BoundLogger,
-    cache_logger_on_first_use=True,
-)
+if not structlog.is_configured():
+    structlog.configure(
+        processors=[
+            structlog.stdlib.filter_by_level,
+            *shared_processors,
+            structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
+        ],
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        wrapper_class=structlog.stdlib.BoundLogger,
+        cache_logger_on_first_use=True,
+    )

langgraph_api/metadata.py

@@ -28,6 +28,7 @@ elif os.getenv("LANGSMITH_HOST_PROJECT_ID"):
 else:
     HOST = "self-hosted"
 PLAN = "enterprise" if plus_features_enabled() else "developer"
+USER_API_URL = os.getenv("LANGGRAPH_API_URL", None)
 
 LOGS: list[dict] = []
 RUN_COUNTER = 0

langgraph_api/models/run.py

@@ -241,7 +241,17 @@ async def create_valid_run(
     # handle multitask strategy
     inflight_runs = [run async for run in run_]
     if first["run_id"] == run_id:
-        logger.info("Created run", run_id=str(run_id), thread_id=str(thread_id))
+        logger.info(
+            "Created run",
+            run_id=str(run_id),
+            thread_id=str(thread_id),
+            assistant_id=str(assistant_id),
+            multitask_strategy=multitask_strategy,
+            stream_mode=stream_mode,
+            temporary=temporary,
+            after_seconds=payload.get("after_seconds", 0),
+            if_not_exists=payload.get("if_not_exists", "reject"),
+        )
         # inserted, proceed
         if multitask_strategy in ("interrupt", "rollback") and inflight_runs:
             try:

langgraph_api/stream.py

@@ -19,15 +19,15 @@ from langgraph.errors import (
     InvalidUpdateError,
 )
 from langgraph.pregel.debug import CheckpointPayload, TaskResultPayload
-from langgraph.types import Command, Send
 from pydantic import ValidationError
 from pydantic.v1 import ValidationError as ValidationErrorLegacy
 
 from langgraph_api.asyncio import ValueEvent, wait_if_not_done
+from langgraph_api.command import map_cmd
 from langgraph_api.graph import get_graph
 from langgraph_api.js.base import BaseRemotePregel
-from langgraph_api.metadata import HOST, PLAN, incr_nodes
-from langgraph_api.schema import Run, RunCommand, StreamMode
+from langgraph_api.metadata import HOST, PLAN, USER_API_URL, incr_nodes
+from langgraph_api.schema import Run, StreamMode
 from langgraph_api.serde import json_dumpb
 from langgraph_api.utils import AsyncConnectionProto
 from langgraph_storage.checkpoint import Checkpointer
@@ -70,32 +70,6 @@ def _preprocess_debug_checkpoint(payload: CheckpointPayload | None) -> dict[str,
     return payload
 
 
-def _map_cmd(cmd: RunCommand) -> Command:
-    goto = cmd.get("goto")
-    if goto is not None and not isinstance(goto, list):
-        goto = [cmd.get("goto")]
-
-    update = cmd.get("update")
-    if isinstance(update, tuple | list) and all(
-        isinstance(t, tuple | list) and len(t) == 2 and isinstance(t[0], str)
-        for t in update
-    ):
-        update = [tuple(t) for t in update]
-
-    return Command(
-        update=update,
-        goto=(
-            [
-                it if isinstance(it, str) else Send(it["node"], it["input"])
-                for it in goto
-            ]
-            if goto
-            else None
-        ),
-        resume=cmd.get("resume"),
-    )
-
-
 async def astream_state(
     stack: AsyncExitStack,
     conn: AsyncConnectionProto,
@@ -125,7 +99,7 @@ async def astream_state(
     )
     input = kwargs.pop("input")
     if cmd := kwargs.pop("command"):
-        input = _map_cmd(cmd)
+        input = map_cmd(cmd)
     stream_mode: list[StreamMode] = kwargs.pop("stream_mode")
     feedback_keys = kwargs.pop("feedback_keys", None)
     stream_modes_set: set[StreamMode] = set(stream_mode) - {"events"}
@@ -140,6 +114,7 @@ async def astream_state(
     config["metadata"]["langgraph_version"] = langgraph.version.__version__
     config["metadata"]["langgraph_plan"] = PLAN
     config["metadata"]["langgraph_host"] = HOST
+    config["metadata"]["langgraph_api_url"] = USER_API_URL
     # attach node counter
     if not isinstance(graph, BaseRemotePregel):
         config["configurable"]["__pregel_node_finished"] = incr_nodes

langgraph_api/validation.py

@@ -27,7 +27,18 @@ AssistantVersionChange = jsonschema_rs.validator_for(
     openapi["components"]["schemas"]["AssistantVersionChange"]
 )
 ThreadCreate = jsonschema_rs.validator_for(
-    openapi["components"]["schemas"]["ThreadCreate"]
+    {
+        **openapi["components"]["schemas"]["ThreadCreate"],
+        "components": {
+            "schemas": {
+                "ThreadSuperstepUpdate": openapi["components"]["schemas"][
+                    "ThreadSuperstepUpdate"
+                ],
+                "Command": openapi["components"]["schemas"]["Command"],
+                "Send": openapi["components"]["schemas"]["Send"],
+            }
+        },
+    }
 )
 ThreadPatch = jsonschema_rs.validator_for(
     openapi["components"]["schemas"]["ThreadPatch"]
@@ -42,6 +53,7 @@ ThreadStateUpdate = jsonschema_rs.validator_for(
         },
     }
 )
+
 ThreadStateCheckpointRequest = jsonschema_rs.validator_for(
     {
         **openapi["components"]["schemas"]["ThreadStateCheckpointRequest"],

langgraph_api/worker.py

@@ -210,7 +210,7 @@ async def worker(
             status = "retry"
             run_ended_at = datetime.now(UTC).isoformat()
             await logger.awarning(
-                "Background run failed, will retry",
+                f"Background run failed, will retry. Exception: {e}",
                 exc_info=True,
                 run_id=str(run_id),
                 run_attempt=attempt,
@@ -226,7 +226,7 @@ async def worker(
             status = "error"
             run_ended_at = datetime.now(UTC).isoformat()
             await logger.aexception(
-                "Background run failed",
+                f"Background run failed. Exception: {exc}",
                 exc_info=not isinstance(exc, RemoteException),
                 run_id=str(run_id),
                 run_attempt=attempt,

{langgraph_api-0.0.31.dist-info → langgraph_api-0.0.33.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langgraph-api
-Version: 0.0.31
+Version: 0.0.33
 Summary: 
 License: Elastic-2.0
 Author: Nuno Campos
@@ -16,7 +16,7 @@ Requires-Dist: jsonschema-rs (>=0.20.0,<0.30)
 Requires-Dist: langchain-core (>=0.2.38,<0.4.0)
 Requires-Dist: langgraph (>=0.2.56,<0.4.0)
 Requires-Dist: langgraph-checkpoint (>=2.0.21,<3.0)
-Requires-Dist: langgraph-sdk (>=0.1.57,<0.2.0)
+Requires-Dist: langgraph-sdk (>=0.1.58,<0.2.0)
 Requires-Dist: langsmith (>=0.1.63,<0.4.0)
 Requires-Dist: orjson (>=3.9.7)
 Requires-Dist: pyjwt (>=2.9.0,<3.0.0)

{langgraph_api-0.0.31.dist-info → langgraph_api-0.0.33.dist-info}/RECORD

@@ -1,14 +1,15 @@
 LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
 langgraph_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/api/__init__.py,sha256=B2kHOBhKjBRdNiWPljYuJFxP__wYPCvgtgTaWYKZGTQ,5129
-langgraph_api/api/assistants.py,sha256=2HEIcxaOJJ4_JQ00TKT1ehx7DMbYCGpvhShK0ZiWsSE,14043
+langgraph_api/api/__init__.py,sha256=iDxgg0arqzZ0-roCSuWo3f8zXmKcl4fuU3Jw0-lqtZs,5447
+langgraph_api/api/assistants.py,sha256=nU6tnbgdr_6Utlq0A9nw2a6xxpUM_DNuCFI42_Kcs_o,14233
+langgraph_api/api/mcp.py,sha256=dpKT9DgIoLERTmYZ4sSOPyHbfGbm7hCyb2MrMS_ol18,13593
 langgraph_api/api/meta.py,sha256=ifJ_Ki0Qf2DYbmY6OKlqKhLGxbt55gm0lEqH1A0cJbw,2790
 langgraph_api/api/openapi.py,sha256=f9gfmWN2AMKNUpLCpSgZuw_aeOF9jCXPdOtFT5PaTWM,10960
 langgraph_api/api/runs.py,sha256=_RWKtmjD89ALnTk56dwo2rJwEi2oghk2Tqp0l1aCcZg,16677
 langgraph_api/api/store.py,sha256=VzAJVOwO0IxosBB7km5TTf2rhlWGyPkVz_LpvbxetVY,5437
-langgraph_api/api/threads.py,sha256=taU61XPcCEhBPCYPZcMDsgVDwwWUWJs8p-PrXFXWY48,8661
+langgraph_api/api/threads.py,sha256=meaDGF3R2bYkx0KRa_le4Ka5nOSeqlMDWtLdnEhVYSY,8930
 langgraph_api/api/ui.py,sha256=LiOZVewKOPbKEykCm30hCEaOA7vuS_Ti5hB32EEy4vw,2082
-langgraph_api/asyncio.py,sha256=ipxOGL0CuKZeHw8895ojtfoBU2fj0iJOp48uhiLAmss,7786
+langgraph_api/asyncio.py,sha256=hVuAxWTHoUyNqTzcIEKTkAvh7HFrdGK6WIDowDxORAE,8397
 langgraph_api/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_api/auth/custom.py,sha256=z69UvpG7wPSXtRmp_UFmA8fY7HeQD4AEIWu3qlpJOBc,21210
 langgraph_api/auth/langsmith/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -17,11 +18,12 @@ langgraph_api/auth/langsmith/client.py,sha256=eKchvAom7hdkUXauD8vHNceBDDUijrFgdT
 langgraph_api/auth/middleware.py,sha256=jU8aDSIZHdzCGdifejRF7ndHkSjBtqIHcBwFIuUdHEA,1875
 langgraph_api/auth/noop.py,sha256=Bk6Nf3p8D_iMVy_OyfPlyiJp_aEwzL-sHrbxoXpCbac,586
 langgraph_api/auth/studio_user.py,sha256=FzFQRROKDlA9JjtBuwyZvk6Mbwno5M9RVYjDO6FU3F8,186
-langgraph_api/cli.py,sha256=3SAwPv8EDKqJx52oD3CB3h0vN7m-LI3lT0RmYFMfkNM,11671
-langgraph_api/config.py,sha256=XMJEVfPe1LrmVKGM5sisQs1eZOUDyU3JwscwJOm0q_k,8572
+langgraph_api/cli.py,sha256=17mTzIhAEaNy9THdtsTqaEBsi5h0J0Tu-EAtv4Qbz5U,11787
+langgraph_api/command.py,sha256=3O9v3i0OPa96ARyJ_oJbLXkfO8rPgDhLCswgO9koTFA,768
+langgraph_api/config.py,sha256=52qcOo9dBfynCozLwzO-Dhew-WgXjPVR2-9nNp6Q-nY,8703
 langgraph_api/cron_scheduler.py,sha256=9yzbbGxzNgJdIg4ZT7yu2oTwT_wRuPxD1c2sbbd52xs,2630
 langgraph_api/errors.py,sha256=Bu_i5drgNTyJcLiyrwVE_6-XrSU50BHf9TDpttki9wQ,1690
-langgraph_api/graph.py,sha256=viFyQa8-BRRNRZqNNUzLB31cB4IypEMkMucQEJQYLWY,16556
+langgraph_api/graph.py,sha256=5Lo9FghptdPIFJoeTDkLjoIQLuNy49RWtAHJmzOCrZI,17209
 langgraph_api/http.py,sha256=gYbxxjY8aLnsXeJymcJ7G7Nj_yToOGpPYQqmZ1_ggfA,5240
 langgraph_api/js/.gitignore,sha256=l5yI6G_V6F1600I1IjiUKn87f4uYIrBAYU1MOyBBhg4,59
 langgraph_api/js/base.py,sha256=BpE8-xkUp8HFPRjSKx1tfUQubvoV4jYl6OwZdre3veI,209
@@ -30,7 +32,7 @@ langgraph_api/js/client.mts,sha256=2dptAX8fMowV9OC4DU4khjpZUgALBLVBTu3jTQbeUJY,2
 langgraph_api/js/errors.py,sha256=Cm1TKWlUCwZReDC5AQ6SgNIVGD27Qov2xcgHyf8-GXo,361
 langgraph_api/js/global.d.ts,sha256=cLJRZfYVGmgQ6o_xFevVNNTIi918ZUdxVRnpLVSjiAY,133
 langgraph_api/js/package.json,sha256=j6DMoVgwRqWqTwdd7R1f-kvmiTUAbO3HaUhM8K64lbE,1224
-langgraph_api/js/remote.py,sha256=jUUgdskUbDR_tuhZFrJo4OewbndQ76joczBv-mZHG9k,22637
+langgraph_api/js/remote.py,sha256=g0H2x3W7kejxswhgZfFaljzl4Y7agMCnO5BdNVj1rDY,23474
 langgraph_api/js/schema.py,sha256=7idnv7URlYUdSNMBXQcw7E4SxaPxCq_Oxwnlml8q5ik,408
 langgraph_api/js/src/graph.mts,sha256=mRyMUp03Fwd5DlmNIFl3RiUCQuJ5XwmFp1AfAeKDfVc,3169
 langgraph_api/js/src/hooks.mjs,sha256=XtktgmIHlls_DsknAuwib-z7TqCm0haRoTXvnkgzMuo,601
@@ -58,14 +60,14 @@ langgraph_api/js/tests/graphs/yarn.lock,sha256=i2AAIgXA3XBLM8-oU45wgUefCSG-Tne4g
 langgraph_api/js/tests/parser.test.mts,sha256=dEC8KTqKygeb1u39ZvpPqCT4HtfPD947nLmITt2buxA,27883
 langgraph_api/js/tests/utils.mts,sha256=2kTybJ3O7Yfe1q3ehDouqV54ibXkNzsPZ_wBZLJvY-4,421
 langgraph_api/js/yarn.lock,sha256=W89dVYZMThcec08lJMcYnvEEnQK7VM5cPglvwpIdRv0,82773
-langgraph_api/lifespan.py,sha256=u5Fv9I4JqfLk30p5cNqkcEqeB2vTRMGSM5WlFHlE0mU,2219
-langgraph_api/logging.py,sha256=KB1ciduIWcMFfG0q9c5_SZemGrscht1RZXLZfeJSS00,3619
-langgraph_api/metadata.py,sha256=jPLNIRxHi7taZ0g60UdOEXenkvDwoYdI11tsmHenb28,3443
+langgraph_api/lifespan.py,sha256=sUQnwszj3VaHKUyOLL8E7Rn7D4S_Vde0U69l739CgOQ,2472
+langgraph_api/logging.py,sha256=JJIzbNIgLCN6ClQ3tA-Mm5ffuBGvpRDSZsEvnIlsuu4,3693
+langgraph_api/metadata.py,sha256=5Mu3MUtUc-iIocU3X2SZDoGIqnUmTdT3517MhP94npI,3495
 langgraph_api/middleware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_api/middleware/http_logger.py,sha256=yuFPNFIWwn-4AE1CogBfWlo8KytzywLi_Bd4ccsyVQE,3150
 langgraph_api/middleware/private_network.py,sha256=eYgdyU8AzU2XJu362i1L8aSFoQRiV7_aLBPw7_EgeqI,2111
 langgraph_api/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/models/run.py,sha256=1TzTmagDXFQD_LhIMRdguZHmrPSzztq1wiMjF63d2fc,9843
+langgraph_api/models/run.py,sha256=J1DpfMwv7W3zX9WtCANyObaCuZWBVfz2JWgdIBa9VzU,10180
 langgraph_api/patch.py,sha256=82xjuFqY7tgrUm-k1XWHI6k8S6QovSD0zhe--8_xW4o,1296
 langgraph_api/queue_entrypoint.py,sha256=4xICUxXarNV8DhnaqAMhVi3xCmyVKCL3J5NzHxPA9Xc,1835
 langgraph_api/route.py,sha256=fM4qYCGbmH0a3_cV8uKocb1sLklehxO6HhdRXqLK6OM,4421
@@ -74,11 +76,11 @@ langgraph_api/serde.py,sha256=VoJ7Z1IuqrQGXFzEP1qijAITtWCrmjtVqlCRuScjXJI,3533
 langgraph_api/server.py,sha256=CiNK327zTsEpoVGeJK1JOtZHvOBYRoz0CnBTZUmsC7c,4567
 langgraph_api/sse.py,sha256=2wNodCOP2eg7a9mpSu0S3FQ0CHk2BBV_vv0UtIgJIcc,4034
 langgraph_api/state.py,sha256=8jx4IoTCOjTJuwzuXJKKFwo1VseHjNnw_CCq4x1SW14,2284
-langgraph_api/stream.py,sha256=LKXxol0y9xEsrgnbsDwyeKIPBDE-75uVz01OcLI-_QE,11976
+langgraph_api/stream.py,sha256=lhjnom-T8GbquUZry-KSkajnqYjElaIERhPiXPtpw1E,11354
 langgraph_api/utils.py,sha256=92mSti9GfGdMRRWyESKQW5yV-75Z9icGHnIrBYvdypU,3619
-langgraph_api/validation.py,sha256=McizHlz-Ez8Jhdbc79mbPSde7GIuf2Jlbjx2yv_l6dA,4475
+langgraph_api/validation.py,sha256=LnEdfgID2Z0HP75R_hqWxCn5d5ULGcDJ3r1xaDVv6-w,4845
 langgraph_api/webhook.py,sha256=1ncwO0rIZcj-Df9sxSnFEzd1gP1bfS4okeZQS8NSRoE,1382
-langgraph_api/worker.py,sha256=7yQfZBANt1kgJDOEs5B5c3Xy65lzNMmngVbBqLs-r5s,9802
+langgraph_api/worker.py,sha256=zlkk2yg1tOBQHYwN-WHjc9NJgd3CAvsl8ET0-7tqQIk,9838
 langgraph_license/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_license/middleware.py,sha256=_ODIYzQkymr6W9_Fp9wtf1kAQspnpsmr53xuzyF2GA0,612
 langgraph_license/validation.py,sha256=Uu_G8UGO_WTlLsBEY0gTVWjRR4czYGfw5YAD3HLZoj0,203
@@ -86,15 +88,15 @@ langgraph_storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 langgraph_storage/checkpoint.py,sha256=V4t2GwYEJdPCHbhq_4Udhlv0TWKDzlMu_rlNPdTDc50,3589
 langgraph_storage/database.py,sha256=I0AgFeJ-NSTT34vxKxQBUf1z2syFP0S8QpKCqTixrzY,5652
 langgraph_storage/inmem_stream.py,sha256=8bxkILIuFpr7P7RQ37SQAxrpRKvmbHdRB_nbfFiomlk,3263
-langgraph_storage/ops.py,sha256=6qj3zh3T7KZco_vz9FW1cI82sbrefo6u2BRmrUDXvZI,69529
+langgraph_storage/ops.py,sha256=0DhtDQllBnV495DPrwhbR_bQUg7ZrGBe0FxSZcicz5g,72469
 langgraph_storage/queue.py,sha256=UDgsUTtUMfBSRDrQ8Onis-FJO4n7KTsX6sdpbY8Hs0A,5055
 langgraph_storage/retry.py,sha256=XmldOP4e_H5s264CagJRVnQMDFcEJR_dldVR1Hm5XvM,763
 langgraph_storage/store.py,sha256=33-J5-Xvobb9ArSa-GezP5KtfXgzWkHUHPyjRYmdw-E,2985
 langgraph_storage/ttl_dict.py,sha256=FlpEY8EANeXWKo_G5nmIotPquABZGyIJyk6HD9u6vqY,1533
 logging.json,sha256=3RNjSADZmDq38eHePMm1CbP6qZ71AmpBtLwCmKU9Zgo,379
-openapi.json,sha256=8NhoZn3Dse6Ia0i7fXCB46sdGnEg5qAhov_8of-6m0o,125282
-langgraph_api-0.0.31.dist-info/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
-langgraph_api-0.0.31.dist-info/METADATA,sha256=lSR24lckxz9BgmrjjqG7b04Q22m5m1W49dHtggG6BeY,4027
-langgraph_api-0.0.31.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-langgraph_api-0.0.31.dist-info/entry_points.txt,sha256=3EYLgj89DfzqJHHYGxPH4A_fEtClvlRbWRUHaXO7hj4,77
-langgraph_api-0.0.31.dist-info/RECORD,,
+openapi.json,sha256=6okfuwPAKB2Hi1tup-EFza49pmN_iD2Yt5JktMALcq4,127984
+langgraph_api-0.0.33.dist-info/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
+langgraph_api-0.0.33.dist-info/METADATA,sha256=PCu4vrh8uCMFyww-JUdBxsrQFN8NrAX9hckbr3SPem0,4027
+langgraph_api-0.0.33.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+langgraph_api-0.0.33.dist-info/entry_points.txt,sha256=3EYLgj89DfzqJHHYGxPH4A_fEtClvlRbWRUHaXO7hj4,77
+langgraph_api-0.0.33.dist-info/RECORD,,

langgraph_storage/ops.py

@@ -22,6 +22,7 @@ from starlette.exceptions import HTTPException
 
 from langgraph_api.asyncio import SimpleTaskGroup, ValueEvent, create_task
 from langgraph_api.auth.custom import handle_event
+from langgraph_api.command import map_cmd
 from langgraph_api.errors import UserInterrupt, UserRollback
 from langgraph_api.graph import get_graph
 from langgraph_api.schema import (
@@ -1081,6 +1082,78 @@ class Threads(Authenticated):
             else:
                 raise HTTPException(status_code=400, detail="Thread has no graph ID.")
 
+        @staticmethod
+        async def bulk(
+            conn: InMemConnectionProto,
+            *,
+            config: Config,
+            supersteps: Sequence[dict],
+            ctx: Auth.types.BaseAuthContext | None = None,
+        ) -> ThreadUpdateResponse:
+            """Update a thread with a batch of state updates."""
+
+            from langgraph.pregel.types import StateUpdate
+
+            thread_id = _ensure_uuid(config["configurable"]["thread_id"])
+            filters = await Threads.handle_event(
+                ctx,
+                "update",
+                Auth.types.ThreadsUpdate(thread_id=thread_id),
+            )
+
+            thread_iter = await Threads.get(conn, thread_id, ctx=ctx)
+            thread = await fetchone(
+                thread_iter, not_found_detail=f"Thread {thread_id} not found."
+            )
+
+            thread_config = thread["config"]
+            metadata = thread["metadata"]
+
+            if not thread:
+                raise HTTPException(status_code=404, detail="Thread not found")
+
+            if not _check_filter_match(metadata, filters):
+                raise HTTPException(status_code=403, detail="Forbidden")
+
+            if graph_id := metadata.get("graph_id"):
+                config["configurable"].setdefault("graph_id", graph_id)
+                config["configurable"].setdefault("checkpoint_ns", "")
+
+                async with get_graph(
+                    graph_id, thread_config, checkpointer=Checkpointer(conn)
+                ) as graph:
+                    next_config = await graph.abulk_update_state(
+                        config,
+                        [
+                            [
+                                StateUpdate(
+                                    map_cmd(update.get("command"))
+                                    if update.get("command")
+                                    else update.get("values"),
+                                    update.get("as_node"),
+                                )
+                                for update in superstep.get("updates", [])
+                            ]
+                            for superstep in supersteps
+                        ],
+                    )
+
+                    state = await Threads.State.get(
+                        conn, config, subgraphs=False, ctx=ctx
+                    )
+
+                    # update thread values
+                    for thread in conn.store["threads"]:
+                        if thread["thread_id"] == thread_id:
+                            thread["values"] = state.values
+                            break
+
+                    return ThreadUpdateResponse(
+                        checkpoint=next_config["configurable"],
+                    )
+            else:
+                raise HTTPException(status_code=400, detail="Thread has no graph ID")
+
         @staticmethod
         async def list(
             conn: InMemConnectionProto,
@@ -1905,7 +1978,8 @@ class Crons:
         conn: InMemConnectionProto,
         ctx: Auth.types.BaseAuthContext | None = None,
     ) -> AsyncIterator[Cron]:
-        raise NotImplementedError
+        yield
+        raise NotImplementedError("The in-mem server does not implement Crons.")
 
     @staticmethod
     async def set_next_run_date(