langgraph-api 0.0.34__tar.gz → 0.0.37__tar.gz

{langgraph_api-0.0.34 → langgraph_api-0.0.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langgraph-api
-Version: 0.0.34
+Version: 0.0.37
 Summary: 
 License: Elastic-2.0
 Author: Nuno Campos
@@ -10,6 +10,7 @@ Classifier: License :: Other/Proprietary License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: cloudpickle (>=3.0.0,<4.0.0)
 Requires-Dist: cryptography (>=43.0.3,<44.0.0)
 Requires-Dist: httpx (>=0.25.0)
 Requires-Dist: jsonschema-rs (>=0.20.0,<0.30)

{langgraph_api-0.0.34 → langgraph_api-0.0.37}/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-0.0.34 → langgraph_api-0.0.37}/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-0.0.34 → langgraph_api-0.0.37}/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-0.0.34 → langgraph_api-0.0.37}/langgraph_api/cli.py

@@ -130,6 +130,7 @@ def run_server(
     auth: AuthConfig | None = None,
     http: typing.Optional["HttpConfig"] = None,
     studio_url: str | None = None,
+    disable_persistence: bool = False,
     **kwargs: typing.Any,
 ):
     """Run the LangGraph API server."""
@@ -178,8 +179,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",
@@ -190,9 +190,19 @@ def run_server(
         LANGGRAPH_AUTH=json.dumps(auth) if auth else None,
         LANGGRAPH_HTTP=json.dumps(http) if http else None,
         LANGGRAPH_API_URL=local_url,
+        LANGGRAPH_DISABLE_FILE_PERSISTENCE=str(disable_persistence).lower(),
         # 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-0.0.34 → langgraph_api-0.0.37}/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-0.0.34 → langgraph_api-0.0.37}/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-0.0.34 → langgraph_api-0.0.37}/langgraph_api/serde.py

@@ -1,5 +1,4 @@
 import asyncio
-import pickle
 import uuid
 from base64 import b64encode
 from collections import deque
@@ -18,9 +17,13 @@ from re import Pattern
 from typing import Any, NamedTuple
 from zoneinfo import ZoneInfo
 
+import cloudpickle
 import orjson
+import structlog
 from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer
 
+logger = structlog.stdlib.get_logger(__name__)
+
 
 class Fragment(NamedTuple):
     buf: bytes
@@ -122,9 +125,15 @@ class Serializer(JsonPlusSerializer):
         try:
             return super().dumps_typed(obj)
         except TypeError:
-            return "pickle", pickle.dumps(obj)
+            return "pickle", cloudpickle.dumps(obj)
 
     def loads_typed(self, data: tuple[str, bytes]) -> Any:
         if data[0] == "pickle":
-            return pickle.loads(data[1])
+            try:
+                return cloudpickle.loads(data[1])
+            except Exception as e:
+                logger.warning(
+                    "Failed to unpickle object, replacing w None", exc_info=e
+                )
+                return None
         return super().loads_typed(data)

{langgraph_api-0.0.34 → langgraph_api-0.0.37}/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-0.0.37/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-0.0.34 → langgraph_api-0.0.37}/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 → langgraph_api-0.0.37}/langgraph_storage/checkpoint.py

@@ -16,6 +16,9 @@ from langgraph_api.serde import Serializer
 logger = logging.getLogger(__name__)
 
 _EXCLUDED_KEYS = {"checkpoint_ns", "checkpoint_id", "run_id", "thread_id"}
+DISABLE_FILE_PERSISTENCE = (
+    os.getenv("LANGGRAPH_DISABLE_FILE_PERSISTENCE", "false").lower() == "true"
+)
 
 
 class InMemorySaver(MemorySaver):
@@ -56,7 +59,7 @@ class InMemorySaver(MemorySaver):
 
         super().__init__(
             serde=serde if serde is not None else Serializer(),
-            factory=factory,
+            factory=factory if not DISABLE_FILE_PERSISTENCE else None,
         )
 
     def put(

{langgraph_api-0.0.34 → langgraph_api-0.0.37}/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_api-0.0.34 → langgraph_api-0.0.37}/langgraph_storage/store.py

@@ -13,13 +13,22 @@ from langgraph.store.memory import InMemoryStore
 from langgraph_api.graph import resolve_embeddings
 
 _STORE_CONFIG = None
+DISABLE_FILE_PERSISTENCE = (
+    os.getenv("LANGGRAPH_DISABLE_FILE_PERSISTENCE", "false").lower() == "true"
+)
 
 
 class DiskBackedInMemStore(InMemoryStore):
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
-        self._data = PersistentDict(dict, filename=_STORE_FILE)
-        self._vectors = PersistentDict(lambda: defaultdict(dict), filename=_VECTOR_FILE)
+        if not DISABLE_FILE_PERSISTENCE:
+            self._data = PersistentDict(dict, filename=_STORE_FILE)
+            self._vectors = PersistentDict(
+                lambda: defaultdict(dict), filename=_VECTOR_FILE
+            )
+        else:
+            self._data = InMemoryStore._data
+            self._vectors = InMemoryStore._vectors
         self._load_data(self._data, which="data")
         self._load_data(self._vectors, which="vectors")
 
@@ -62,6 +71,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()
 

{langgraph_api-0.0.34 → langgraph_api-0.0.37}/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": [

{langgraph_api-0.0.34 → langgraph_api-0.0.37}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langgraph-api"
-version = "0.0.34"
+version = "0.0.37"
 description = ""
 authors = [
     "Nuno Campos <nuno@langchain.dev>",
@@ -36,6 +36,7 @@ structlog = ">=24.1.0,<26"
 pyjwt = "^2.9.0"
 cryptography = "^43.0.3"
 langgraph-sdk = "^0.1.58"
+cloudpickle = "^3.0.0"
 
 [tool.poetry.group.dev.dependencies]
 ruff = "^0.6.2"