langgraph-api 0.0.34__py3-none-any.whl → 0.0.36__py3-none-any.whl

langgraph_api/api/runs.py

@@ -1,8 +1,10 @@
 import asyncio
 from collections.abc import AsyncIterator
+from typing import Literal
 
 import orjson
 from langgraph.checkpoint.base.id import uuid6
+from starlette.exceptions import HTTPException
 from starlette.responses import Response, StreamingResponse
 
 from langgraph_api import config
@@ -17,6 +19,7 @@ from langgraph_api.validation import (
     RunBatchCreate,
     RunCreateStateful,
     RunCreateStateless,
+    RunsCancel,
 )
 from langgraph_license.validation import plus_features_enabled
 from langgraph_storage.database import connect
@@ -394,6 +397,44 @@ async def cancel_run(
     return Response(status_code=204 if wait else 202)
 
 
+@retry_db
+async def cancel_runs(
+    request: ApiRequest,
+):
+    """Cancel a run."""
+    body = await request.json(RunsCancel)
+    status = body.get("status")
+    if status:
+        status = status.lower()
+        if status not in ("pending", "running", "all"):
+            raise HTTPException(
+                status_code=422,
+                detail="Invalid status: must be 'pending', 'running', or 'all'",
+            )
+        thread_id = None
+        run_ids = None
+    else:
+        thread_id = body.get("thread_id")
+        run_ids = body.get("run_ids")
+        validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
+        for rid in run_ids:
+            validate_uuid(rid, "Invalid run ID: must be a UUID")
+    action_str = request.query_params.get("action", "interrupt")
+    action: Literal["interrupt", "rollback"] = (
+        action_str if action_str in ("interrupt", "rollback") else "interrupt"
+    )
+
+    async with connect() as conn:
+        await Runs.cancel(
+            conn,
+            run_ids,
+            action=action,
+            thread_id=thread_id,
+            status=status,
+        )
+    return Response(status_code=204)
+
+
 @retry_db
 async def delete_run(request: ApiRequest):
     """Delete a run by ID."""
@@ -486,6 +527,7 @@ runs_routes = [
     ApiRoute("/runs/wait", wait_run_stateless, methods=["POST"]),
     ApiRoute("/runs", create_stateless_run, methods=["POST"]),
     ApiRoute("/runs/batch", create_stateless_run_batch, methods=["POST"]),
+    ApiRoute("/runs/cancel", cancel_runs, methods=["POST"]),
     (
         ApiRoute("/runs/crons", create_cron, methods=["POST"])
         if config.FF_CRONS_ENABLED and plus_features_enabled()

langgraph_api/api/threads.py

@@ -34,6 +34,7 @@ async def create_thread(
             thread_id,
             metadata=payload.get("metadata"),
             if_exists=payload.get("if_exists") or "raise",
+            ttl=payload.get("ttl"),
         )
 
         if supersteps := payload.get("supersteps"):

langgraph_api/auth/custom.py

@@ -176,21 +176,14 @@ class CustomAuthBackend(AuthenticationBackend):
         except (AuthenticationError, HTTPException):
             raise
         except Auth.exceptions.HTTPException as e:
-            raise HTTPException(
-                status_code=e.status_code,
-                detail=e.detail,
-                headers=dict(e.headers) if e.headers else None,
-            ) from None
-        except AssertionError as e:
-            raise AuthenticationError(str(e)) from None
+            if e.status_code == 401 or e.status_code == 403:
+                raise AuthenticationError(e.detail) from None
+            else:
+                await logger.aerror("Error authenticating request", exc_info=e)
+                raise
         except Exception as e:
             await logger.aerror("Error authenticating request", exc_info=e)
-            status_code = getattr(e, "status_code", 401)
-            detail = getattr(e, "detail", "Unauthorized")
-            headers = getattr(e, "headers", None)
-            raise HTTPException(
-                status_code=status_code, detail=detail, headers=headers
-            ) from None
+            raise e
 
 
 def _get_custom_auth_middleware(

langgraph_api/cli.py

@@ -178,8 +178,7 @@ def run_server(
             logger.info("Debugger attached. Starting server...")
 
     local_url = f"http://{host}:{port}"
-
-    with patch_environment(
+    to_patch = dict(
         MIGRATIONS_PATH="__inmem",
         DATABASE_URI=":memory:",
         REDIS_URI="fake",
@@ -192,7 +191,16 @@ def run_server(
         LANGGRAPH_API_URL=local_url,
         # See https://developer.chrome.com/blog/private-network-access-update-2024-03
         ALLOW_PRIVATE_NETWORK="true",
-        **(env_vars or {}),
+    )
+    if env_vars is not None:
+        # Don't overwrite.
+        for k, v in env_vars.items():
+            if k in to_patch:
+                logger.debug(f"Skipping loaded env var {k}={v}")
+                continue
+            to_patch[k] = v
+    with patch_environment(
+        **to_patch,
     ):
         studio_origin = studio_url or _get_ls_origin() or "https://smith.langchain.com"
         full_studio_url = f"{studio_origin}/studio/?baseUrl={local_url}"

langgraph_api/config.py

@@ -39,6 +39,12 @@ class HttpConfig(TypedDict, total=False):
     """Disable /mcp routes"""
 
 
+class ThreadTTLConfig(TypedDict, total=False):
+    strategy: Literal["delete"]
+    default_ttl: float | None
+    sweep_interval_minutes: int | None
+
+
 class IndexConfig(TypedDict, total=False):
     """Configuration for indexing documents for semantic search in the store."""
 
@@ -204,6 +210,23 @@ BG_JOB_MAX_RETRIES = 3
 BG_JOB_ISOLATED_LOOPS = env("BG_JOB_ISOLATED_LOOPS", cast=bool, default=False)
 
 
+def _parse_thread_ttl(value: str | None) -> ThreadTTLConfig | None:
+    if not value:
+        return None
+    if str(value).strip().startswith("{"):
+        return _parse_json(value.strip())
+    return {
+        "strategy": "delete",
+        # We permit float values mainly for testing purposes
+        "default_ttl": float(value),
+        "sweep_interval_minutes": 5.1,
+    }
+
+
+THREAD_TTL: ThreadTTLConfig | None = env(
+    "LANGGRAPH_THREAD_TTL", cast=_parse_thread_ttl, default=None
+)
+
 N_JOBS_PER_WORKER = env("N_JOBS_PER_WORKER", cast=int, default=10)
 BG_JOB_TIMEOUT_SECS = env("BG_JOB_TIMEOUT_SECS", cast=float, default=3600)
 FF_CRONS_ENABLED = env("FF_CRONS_ENABLED", cast=bool, default=True)

langgraph_api/lifespan.py

@@ -2,6 +2,8 @@ import asyncio
 from contextlib import asynccontextmanager
 
 import structlog
+from langchain_core.runnables.config import var_child_runnable_config
+from langgraph.constants import CONF, CONFIG_KEY_STORE
 from starlette.applications import Starlette
 
 import langgraph_api.config as config
@@ -10,6 +12,7 @@ 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
 from langgraph_api.metadata import metadata_loop
+from langgraph_api.thread_ttl import thread_ttl_sweep_loop
 from langgraph_license.validation import get_license_status, plus_features_enabled
 from langgraph_storage.database import start_pool, stop_pool
 from langgraph_storage.queue import queue
@@ -54,8 +57,11 @@ async def lifespan(
                 and plus_features_enabled()
             ):
                 tg.create_task(cron_scheduler())
-            if config.STORE_CONFIG and config.STORE_CONFIG.get("ttl"):
-                tg.create_task(Store().start_ttl_sweeper())
+            store = Store()
+            tg.create_task(Store().start_ttl_sweeper())
+            tg.create_task(thread_ttl_sweep_loop())
+            var_child_runnable_config.set({CONF: {CONFIG_KEY_STORE: store}})
+
             yield
     finally:
         await stop_remote_graphs()

langgraph_api/server.py

@@ -16,7 +16,7 @@ from starlette.middleware.cors import CORSMiddleware
 from langgraph_api.api.openapi import set_custom_spec
 
 import langgraph_api.config as config
-from langgraph_api.api import routes, user_router
+from langgraph_api.api import routes, meta_routes, user_router
 from langgraph_api.errors import (
     overloaded_error_handler,
     validation_error_handler,
@@ -92,6 +92,15 @@ def update_openapi_spec(app):
 if user_router:
     # Merge routes
     app = user_router
+
+    meta_route_paths = [route.path for route in meta_routes]
+    custom_route_paths = [
+        route.path
+        for route in user_router.router.routes
+        if route.path not in meta_route_paths
+    ]
+    logger.info(f"Custom route paths: {custom_route_paths}")
+
     update_openapi_spec(app)
     for route in routes:
         if route.path in ("/docs", "/openapi.json"):

langgraph_api/thread_ttl.py

@@ -0,0 +1,46 @@
+"""Sweeping logic for cleaning up expired threads and checkpoints."""
+
+import asyncio
+
+import structlog
+
+from langgraph_api.config import THREAD_TTL
+from langgraph_storage.database import connect
+
+logger = structlog.stdlib.get_logger(__name__)
+
+
+async def thread_ttl_sweep_loop():
+    """Periodically delete threads based on TTL configuration.
+
+    Currently implements the 'delete' strategy, which deletes entire threads
+    that have been inactive for longer than their configured TTL period.
+    """
+    # Use the same interval as store TTL sweep
+    thread_ttl_config = THREAD_TTL or {}
+    strategy = thread_ttl_config.get("strategy", "delete")
+    if strategy != "delete":
+        raise NotImplementedError(
+            f"Unrecognized thread deletion strategy: {strategy}." " Expected 'delete'."
+        )
+    sweep_interval_minutes = thread_ttl_config.get("sweep_interval_minutes", 5)
+    await logger.ainfo(
+        "Starting thread TTL sweeper",
+        interval_minutes=sweep_interval_minutes,
+    )
+
+    from langgraph_storage.ops import Threads
+
+    while True:
+        await asyncio.sleep(sweep_interval_minutes * 60)
+        try:
+            async with connect() as conn:
+                threads_processed, threads_deleted = await Threads.sweep_ttl(conn)
+                if threads_processed > 0:
+                    await logger.ainfo(
+                        "Thread TTL sweep completed",
+                        threads_processed=threads_processed,
+                        threads_deleted=threads_deleted,
+                    )
+        except Exception as exc:
+            logger.exception("Thread TTL sweep iteration failed", exc_info=exc)

langgraph_api/validation.py

@@ -113,6 +113,7 @@ RunCreateStateful = jsonschema_rs.validator_for(
         },
     }
 )
+RunsCancel = jsonschema_rs.validator_for(openapi["components"]["schemas"]["RunsCancel"])
 CronCreate = jsonschema_rs.validator_for(openapi["components"]["schemas"]["CronCreate"])
 CronSearch = jsonschema_rs.validator_for(openapi["components"]["schemas"]["CronSearch"])
 

{langgraph_api-0.0.34.dist-info → langgraph_api-0.0.36.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langgraph-api
-Version: 0.0.34
+Version: 0.0.36
 Summary: 
 License: Elastic-2.0
 Author: Nuno Campos

{langgraph_api-0.0.34.dist-info → langgraph_api-0.0.36.dist-info}/RECORD

@@ -5,22 +5,22 @@ langgraph_api/api/assistants.py,sha256=nU6tnbgdr_6Utlq0A9nw2a6xxpUM_DNuCFI42_Kcs
 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/runs.py,sha256=uijgtrw_FSf1lZHsx8pM-CIj_ur2O88Y7ys-CJZ4SNQ,17988
 langgraph_api/api/store.py,sha256=VzAJVOwO0IxosBB7km5TTf2rhlWGyPkVz_LpvbxetVY,5437
-langgraph_api/api/threads.py,sha256=meaDGF3R2bYkx0KRa_le4Ka5nOSeqlMDWtLdnEhVYSY,8930
+langgraph_api/api/threads.py,sha256=kvv8pmRoUIvPFEuAhJpMC6qMv7Xo5itrzb5EzJFyWMg,8966
 langgraph_api/api/ui.py,sha256=LiOZVewKOPbKEykCm30hCEaOA7vuS_Ti5hB32EEy4vw,2082
 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/custom.py,sha256=Gays0bYwZmRQA8-LSmQSNp1zS2_NG_xybG2cW79YweU,20890
 langgraph_api/auth/langsmith/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_api/auth/langsmith/backend.py,sha256=InScaL-HYCnxYEauhxU198gRZV9pJn9SzzBoR9Edn7g,2654
 langgraph_api/auth/langsmith/client.py,sha256=eKchvAom7hdkUXauD8vHNceBDDUijrFgdTV8bKd7x4Q,3998
 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=17mTzIhAEaNy9THdtsTqaEBsi5h0J0Tu-EAtv4Qbz5U,11787
+langgraph_api/cli.py,sha256=cSRKZzaxSbfDQO3-2YWAo2NgeE5IK0mabYWt4m5q-dU,12047
 langgraph_api/command.py,sha256=3O9v3i0OPa96ARyJ_oJbLXkfO8rPgDhLCswgO9koTFA,768
-langgraph_api/config.py,sha256=52qcOo9dBfynCozLwzO-Dhew-WgXjPVR2-9nNp6Q-nY,8703
+langgraph_api/config.py,sha256=MwTyJUr2wwZdUbL0gIvol_cCGi24Py9DvBnSozE1ai8,9342
 langgraph_api/cron_scheduler.py,sha256=9yzbbGxzNgJdIg4ZT7yu2oTwT_wRuPxD1c2sbbd52xs,2630
 langgraph_api/errors.py,sha256=Bu_i5drgNTyJcLiyrwVE_6-XrSU50BHf9TDpttki9wQ,1690
 langgraph_api/graph.py,sha256=5Lo9FghptdPIFJoeTDkLjoIQLuNy49RWtAHJmzOCrZI,17209
@@ -60,7 +60,7 @@ 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=sUQnwszj3VaHKUyOLL8E7Rn7D4S_Vde0U69l739CgOQ,2472
+langgraph_api/lifespan.py,sha256=0F4Xn6IC4wUfvBWbm6KCJ-jiF0S7iWDOHJYJZ-A3o3s,2739
 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
@@ -73,12 +73,13 @@ langgraph_api/queue_entrypoint.py,sha256=4xICUxXarNV8DhnaqAMhVi3xCmyVKCL3J5NzHxP
 langgraph_api/route.py,sha256=fM4qYCGbmH0a3_cV8uKocb1sLklehxO6HhdRXqLK6OM,4421
 langgraph_api/schema.py,sha256=hNbg6ep2wiGBBtBJVNBgMYA8uC33AfaqhRXXVUY_At8,5361
 langgraph_api/serde.py,sha256=HfaIBNfdKg2W_mIpw_er5irG3GlIiiVqkqfbDgnYHpg,3671
-langgraph_api/server.py,sha256=CiNK327zTsEpoVGeJK1JOtZHvOBYRoz0CnBTZUmsC7c,4567
+langgraph_api/server.py,sha256=bnXOOYztQmqR-QVpEFoRWB5Fzd33PuEIlwBK2R7W8NE,4849
 langgraph_api/sse.py,sha256=2wNodCOP2eg7a9mpSu0S3FQ0CHk2BBV_vv0UtIgJIcc,4034
 langgraph_api/state.py,sha256=8jx4IoTCOjTJuwzuXJKKFwo1VseHjNnw_CCq4x1SW14,2284
 langgraph_api/stream.py,sha256=lhjnom-T8GbquUZry-KSkajnqYjElaIERhPiXPtpw1E,11354
+langgraph_api/thread_ttl.py,sha256=ubkWMymTR7p9nGWd60-WKEOQ20ZgIkWB6WGstQUmRS4,1658
 langgraph_api/utils.py,sha256=92mSti9GfGdMRRWyESKQW5yV-75Z9icGHnIrBYvdypU,3619
-langgraph_api/validation.py,sha256=LnEdfgID2Z0HP75R_hqWxCn5d5ULGcDJ3r1xaDVv6-w,4845
+langgraph_api/validation.py,sha256=Qo3EkSRXzIRe3GRuqRWbElTcUXRMXMyA1w0VbMvdwME,4934
 langgraph_api/webhook.py,sha256=1ncwO0rIZcj-Df9sxSnFEzd1gP1bfS4okeZQS8NSRoE,1382
 langgraph_api/worker.py,sha256=zlkk2yg1tOBQHYwN-WHjc9NJgd3CAvsl8ET0-7tqQIk,9838
 langgraph_license/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -88,15 +89,15 @@ langgraph_storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 langgraph_storage/checkpoint.py,sha256=X6YHrCwIPVE0iEQy16GhleyyHUdXdCkC-c-Q1SW-rAM,3884
 langgraph_storage/database.py,sha256=I0AgFeJ-NSTT34vxKxQBUf1z2syFP0S8QpKCqTixrzY,5652
 langgraph_storage/inmem_stream.py,sha256=8bxkILIuFpr7P7RQ37SQAxrpRKvmbHdRB_nbfFiomlk,3263
-langgraph_storage/ops.py,sha256=bCgQd7VVezTsTZQe4QlWk-TZiD5YkUFU0_vi7Gxg4YE,72963
+langgraph_storage/ops.py,sha256=S0QHbnquEXvAM63NQMgqtyTjm-8nlq0pOvgJgFD38Z8,75312
 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/store.py,sha256=8QSM0gm6ZV40antWw0YHfnU71swZRsozjd85R-MSrjg,3100
 langgraph_storage/ttl_dict.py,sha256=FlpEY8EANeXWKo_G5nmIotPquABZGyIJyk6HD9u6vqY,1533
 logging.json,sha256=3RNjSADZmDq38eHePMm1CbP6qZ71AmpBtLwCmKU9Zgo,379
-openapi.json,sha256=6okfuwPAKB2Hi1tup-EFza49pmN_iD2Yt5JktMALcq4,127984
-langgraph_api-0.0.34.dist-info/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
-langgraph_api-0.0.34.dist-info/METADATA,sha256=w65HKkHiBPnTZRwJQyFjMTU9TE-kjQnOajtuUL2aBng,4027
-langgraph_api-0.0.34.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-langgraph_api-0.0.34.dist-info/entry_points.txt,sha256=3EYLgj89DfzqJHHYGxPH4A_fEtClvlRbWRUHaXO7hj4,77
-langgraph_api-0.0.34.dist-info/RECORD,,
+openapi.json,sha256=-25y3NRQ88e_944UXo76Goa34HJhC7pj6I9tjYUwvuE,131492
+langgraph_api-0.0.36.dist-info/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
+langgraph_api-0.0.36.dist-info/METADATA,sha256=T5nIH34PPCdvY8DcFJWKDgrrNutgpgwXGmv52fX_2AI,4027
+langgraph_api-0.0.36.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+langgraph_api-0.0.36.dist-info/entry_points.txt,sha256=3EYLgj89DfzqJHHYGxPH4A_fEtClvlRbWRUHaXO7hj4,77
+langgraph_api-0.0.36.dist-info/RECORD,,

langgraph_storage/ops.py

@@ -24,6 +24,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.config import ThreadTTLConfig
 from langgraph_api.errors import UserInterrupt, UserRollback
 from langgraph_api.graph import get_graph
 from langgraph_api.schema import (
@@ -672,6 +673,7 @@ class Threads(Authenticated):
         *,
         metadata: MetadataInput,
         if_exists: OnConflictBehavior,
+        ttl: ThreadTTLConfig | None = None,
         ctx: Auth.types.BaseAuthContext | None = None,
     ) -> AsyncIterator[Thread]:
         """Insert or update a thread."""
@@ -961,6 +963,16 @@ class Threads(Authenticated):
 
             return row_generator()
 
+    @staticmethod
+    async def sweep_ttl(
+        conn: InMemConnectionProto,
+        *,
+        limit: int | None = None,
+        batch_size: int = 100,
+    ) -> tuple[int, int]:
+        # Not implemented for inmem server
+        return (0, 0)
+
     class State(Authenticated):
         # We will treat this like a runs resource for now.
         resource = "threads"
@@ -1453,6 +1465,7 @@ class Runs(Authenticated):
                 ),
                 created_at=datetime.now(UTC),
                 updated_at=datetime.now(UTC),
+                values=b"",
             )
             await logger.ainfo("Creating thread", thread_id=thread_id)
             conn.store["threads"].append(thread)
@@ -1669,88 +1682,140 @@ class Runs(Authenticated):
     @staticmethod
     async def cancel(
         conn: InMemConnectionProto,
-        run_ids: Sequence[UUID],
+        run_ids: Sequence[UUID] | None = None,
         *,
         action: Literal["interrupt", "rollback"] = "interrupt",
-        thread_id: UUID,
+        thread_id: UUID | None = None,
+        status: Literal["pending", "running", "all"] | None = None,
         ctx: Auth.types.BaseAuthContext | None = None,
     ) -> None:
-        """Cancel a run."""
-        # Authwise, this invokes the runs.update handler
-        # Cancellation tries to take two actions, to cover runs in different states:
-        # - For any run, send a cancellation message through the stream manager
-        # - For queued runs not yet picked up by a worker, update their status if interrupt,
-        #       delete if rollback.
-        # - For runs currently being worked on, the worker will handle cancellation
-        # - For runs in any other state, we raise a 404
-        run_ids = [_ensure_uuid(run_id) for run_id in run_ids]
-        thread_id = _ensure_uuid(thread_id)
+        """
+        Cancel runs in memory. Must provide either:
+        1) thread_id + run_ids, or
+        2) status in {"pending", "running", "all"}.
+
+        Steps:
+        - Validate arguments (one usage pattern or the other).
+        - Auth check: 'update' event via handle_event().
+        - Gather runs matching either the (thread_id, run_ids) set or the given status.
+        - For each run found:
+            * Send a cancellation message through the stream manager.
+            * If 'pending', set to 'interrupted' or delete (if action='rollback' and not actively queued).
+            * If 'running', the worker will pick up the message.
+            * Otherwise, log a warning for non-cancelable states.
+        - 404 if no runs are found or authorized.
+        """
+        # 1. Validate arguments
+        if status is not None:
+            # If status is set, user must NOT specify thread_id or run_ids
+            if thread_id is not None or run_ids is not None:
+                raise HTTPException(
+                    status_code=422,
+                    detail="Cannot specify 'thread_id' or 'run_ids' when using 'status'",
+                )
+        else:
+            # If status is not set, user must specify both thread_id and run_ids
+            if thread_id is None or run_ids is None:
+                raise HTTPException(
+                    status_code=422,
+                    detail="Must provide either a status or both 'thread_id' and 'run_ids'",
+                )
+
+        # Convert and normalize inputs
+        if run_ids is not None:
+            run_ids = [_ensure_uuid(rid) for rid in run_ids]
+        if thread_id is not None:
+            thread_id = _ensure_uuid(thread_id)
+
         filters = await Runs.handle_event(
             ctx,
             "update",
             Auth.types.ThreadsUpdate(
-                thread_id=thread_id,
+                thread_id=thread_id,  # type: ignore
                 action=action,
-                metadata={"run_ids": run_ids},
+                metadata={
+                    "run_ids": run_ids,
+                    "status": status,
+                },
             ),
         )
 
+        status_list: tuple[str, ...] = ()
+        if status is not None:
+            if status == "all":
+                status_list = ("pending", "running")
+            elif status in ("pending", "running"):
+                status_list = (status,)
+            else:
+                raise ValueError(f"Unsupported status: {status}")
+
+        def is_run_match(r: dict) -> bool:
+            """
+            Check whether a run in `conn.store["runs"]` meets the selection criteria.
+            """
+            if status_list:
+                return r["status"] in status_list
+            else:
+                return r["thread_id"] == thread_id and r["run_id"] in run_ids  # type: ignore
+
+        candidate_runs = [r for r in conn.store["runs"] if is_run_match(r)]
+
+        if filters:
+            # If a run is found but not authorized by the thread filters, skip it
+            thread = (
+                await Threads._get_with_filters(conn, thread_id, filters)
+                if thread_id
+                else None
+            )
+            # If there's no matching thread, no runs are authorized.
+            if thread_id and not thread:
+                candidate_runs = []
+            # Otherwise, we might trust that `_get_with_filters` is the only constraint
+            # on thread. If your filters also apply to runs, you might do more checks here.
+
+        if not candidate_runs:
+            raise HTTPException(status_code=404, detail="No runs found to cancel.")
+
         stream_manager = get_stream_manager()
-        found_runs = []
         coros = []
-        for run_id in run_ids:
-            run = next(
-                (
-                    r
-                    for r in conn.store["runs"]
-                    if r["run_id"] == run_id and r["thread_id"] == thread_id
-                ),
-                None,
+        for run in candidate_runs:
+            run_id = run["run_id"]
+            control_message = Message(
+                topic=f"run:{run_id}:control".encode(),
+                data=action.encode(),
             )
-            if run:
-                if filters:
-                    thread = await Threads._get_with_filters(conn, thread_id, filters)
-                    if not thread:
-                        continue
-                found_runs.append(run)
-                # Send cancellation message through stream manager
-                control_message = Message(
-                    topic=f"run:{run_id}:control".encode(),
-                    data=action.encode(),
-                )
-                queues = stream_manager.get_queues(run_id)
-                coros.append(stream_manager.put(run_id, control_message))
-
-                # Update status for pending runs
-                if run["status"] in ("pending", "running"):
-                    if queues or action != "rollback":
-                        run["status"] = "interrupted"
-                        run["updated_at"] = datetime.now(tz=UTC)
-                    else:
-                        await logger.ainfo(
-                            "Eagerly deleting unscheduled run with rollback action",
-                            run_id=run_id,
-                            thread_id=thread_id,
-                        )
-                        coros.append(Runs.delete(conn, run_id, thread_id=thread_id))
+            coros.append(stream_manager.put(run_id, control_message))
+
+            queues = stream_manager.get_queues(run_id)
 
+            if run["status"] in ("pending", "running"):
+                if queues or action != "rollback":
+                    run["status"] = "interrupted"
+                    run["updated_at"] = datetime.now(tz=UTC)
                 else:
-                    await logger.awarning(
-                        "Attempted to cancel non-pending run.",
-                        run_id=run_id,
+                    await logger.ainfo(
+                        "Eagerly deleting pending run with rollback action",
+                        run_id=str(run_id),
                         status=run["status"],
                     )
+                    coros.append(Runs.delete(conn, run_id, thread_id=run["thread_id"]))
+            else:
+                await logger.awarning(
+                    "Attempted to cancel non-pending run.",
+                    run_id=str(run_id),
+                    status=run["status"],
+                )
+
         if coros:
             await asyncio.gather(*coros)
-        if len(found_runs) == len(run_ids):
-            await logger.ainfo(
-                "Cancelled runs",
-                run_ids=[str(run_id) for run_id in run_ids],
-                thread_id=str(thread_id),
-                action=action,
-            )
-        else:
-            raise HTTPException(status_code=404, detail="Run not found")
+
+        await logger.ainfo(
+            "Cancelled runs",
+            run_ids=[str(r["run_id"]) for r in candidate_runs],
+            thread_id=str(thread_id) if thread_id else None,
+            status=status,
+            action=action,
+        )
 
     @staticmethod
     async def search(

langgraph_storage/store.py

@@ -62,6 +62,9 @@ class BatchedStore(AsyncBatchedBaseStore):
     async def abatch(self, ops: Iterable[Op]) -> list[Result]:
         return await self._store.abatch(ops)
 
+    async def start_ttl_sweeper(self) -> asyncio.Task[None]:
+        return await self._store.start_ttl_sweeper()
+
     def close(self) -> None:
         self._store.close()
 

openapi.json

@@ -2268,6 +2268,68 @@
         }
       }
     },
+    "/runs/cancel": {
+      "post": {
+        "tags": [
+          "Thread Runs"
+        ],
+        "summary": "Cancel Runs",
+        "description": "Cancel one or more runs. Can cancel runs by thread ID and run IDs, or by status filter.",
+        "operationId": "cancel_runs_post",
+        "parameters": [
+          {
+            "description": "Action to take when cancelling the run. Possible values are `interrupt` or `rollback`. `interrupt` will simply cancel the run. `rollback` will cancel the run and delete the run and associated checkpoints afterwards.",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "enum": [
+                "interrupt",
+                "rollback"
+              ],
+              "title": "Action",
+              "default": "interrupt"
+            },
+            "name": "action",
+            "in": "query"
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/RunsCancel"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "204": {
+            "description": "Success - Runs cancelled"
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
     "/runs/wait": {
       "post": {
         "tags": [
@@ -3959,6 +4021,23 @@
             "description": "How to handle duplicate creation. Must be either 'raise' (raise error if duplicate), or 'do_nothing' (return existing thread).",
             "default": "raise"
           },
+          "ttl": {
+            "type": "object",
+            "title": "TTL",
+            "description": "The time-to-live for the thread.",
+            "properties": {
+              "strategy": {
+                "type": "string",
+                "enum": ["delete"],
+                "description": "The TTL strategy. 'delete' removes the entire thread.",
+                "default": "delete"
+              },
+              "ttl": {
+                "type": "number",
+                "description": "The time-to-live in minutes from now until thread should be swept."
+              }
+            }
+          },
           "supersteps": {
             "type": "array",
             "items": {
@@ -4398,6 +4477,42 @@
         },
         "description": "Represents a single document or data entry in the graph's Store. Items are used to store cross-thread memories."
       },
+      "RunsCancel": {
+        "type": "object",
+        "title": "RunsCancel",
+        "description": "Payload for cancelling runs.",
+        "properties": {
+          "status": {
+            "type": "string",
+            "enum": ["pending", "running", "all"],
+            "title": "Status",
+            "description": "Filter runs by status to cancel. Must be one of 'pending', 'running', or 'all'."
+          },
+          "thread_id": {
+            "type": "string",
+            "format": "uuid",
+            "title": "Thread Id",
+            "description": "The ID of the thread containing runs to cancel."
+          },
+          "run_ids": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "format": "uuid"
+            },
+            "title": "Run Ids",
+            "description": "List of run IDs to cancel."
+          }
+        },
+        "oneOf": [
+          {
+            "required": ["status"]
+          },
+          {
+            "required": ["thread_id", "run_ids"]
+          }
+        ]
+      },
       "SearchItemsResponse": {
         "type": "object",
         "required": [