langgraph-api 0.7.31__tar.gz → 0.7.33__tar.gz

{langgraph_api-0.7.31 → langgraph_api-0.7.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.7.31
+Version: 0.7.33
 Author-email: Will Fu-Hinthorn <will@langchain.dev>, Josh Rogers <josh@langchain.dev>, Parker Rule <parker@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE

langgraph_api-0.7.33/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.7.33"

{langgraph_api-0.7.31 → langgraph_api-0.7.33}/langgraph_api/_checkpointer/__init__.py

@@ -25,6 +25,8 @@ async def get_checkpointer(
 
 async def start_checkpointer() -> None:
     """Start the checkpointer resources."""
+    # Load the custom checkpointer from LANGGRAPH_CHECKPOINTER env var, if configured.
+    await _adapter.collect_checkpointer_from_env()
     # If the custom checkpointer is provided, it will be started here / enter the stack.
     checkpointer = await get_checkpointer()
     if not isinstance(checkpointer, (BaseCheckpointSaver, CheckpointerProtocol)):
@@ -44,8 +46,14 @@ async def exit_checkpointer() -> None:
     await _adapter.exit_checkpointer()
 
 
+def get_checkpointer_capabilities() -> _adapter.CheckpointerCapabilities | None:
+    """Return the capabilities of the custom checkpointer, or None if not configured."""
+    return _adapter.get_checkpointer_capabilities()
+
+
 __all__ = [
     "exit_checkpointer",
     "get_checkpointer",
+    "get_checkpointer_capabilities",
     "start_checkpointer",
 ]

{langgraph_api-0.7.31 → langgraph_api-0.7.33}/langgraph_api/_checkpointer/_adapter.py

@@ -5,7 +5,7 @@ import importlib.util
 import random
 import sys
 import threading
-from collections.abc import AsyncIterator, Callable, Sequence
+from collections.abc import AsyncIterator, Callable
 from contextlib import AsyncExitStack, asynccontextmanager
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Self, cast
@@ -25,7 +25,7 @@ from langgraph_api.timing import profiled_import
 from langgraph_api.utils.config import run_in_executor
 
 if TYPE_CHECKING:
-    from collections.abc import AsyncIterator, Callable, Sequence
+    from collections.abc import AsyncIterator, Callable, Iterable, Sequence
 
     from langchain_core.runnables import RunnableConfig
     from langgraph.checkpoint.base import (
@@ -63,6 +63,9 @@ class CheckpointerCapabilities:
 
     has_aget_iter: bool
     has_adelete_thread: bool
+    has_adelete_for_runs: bool
+    has_acopy_thread: bool
+    has_aprune: bool
 
     @classmethod
     def from_type(cls: type[Self], inner_type: type) -> Self:
@@ -70,6 +73,9 @@ class CheckpointerCapabilities:
         return cls(
             has_aget_iter=_is_overridden(inner_type, "aget_iter"),
             has_adelete_thread=_is_overridden(inner_type, "adelete_thread"),
+            has_adelete_for_runs=_has_method(inner_type, "adelete_for_runs"),
+            has_acopy_thread=_has_method(inner_type, "acopy_thread"),
+            has_aprune=_has_method(inner_type, "aprune"),
         )
 
 
@@ -80,7 +86,6 @@ class _CustomCheckpointerAdapter(BaseCheckpointSaver):
         _validate_required_methods(inner)
         self._inner = inner
         self._capabilities = capabilities
-        self.latest_iter: AsyncIterator[CheckpointTuple] | None = None
         super().__init__(serde=getattr(inner, "serde", None))
 
     def __getattr__(self, name: str) -> Any:
@@ -106,7 +111,7 @@ class _CustomCheckpointerAdapter(BaseCheckpointSaver):
         metadata: CheckpointMetadata,
         new_versions: ChannelVersions,
     ) -> RunnableConfig:
-        metadata = _ensure_run_id(metadata, config)
+        metadata = _enrich_metadata(metadata, config)
         return await self._inner.aput(config, checkpoint, metadata, new_versions)
 
     async def aput_writes(
@@ -142,23 +147,36 @@ class _CustomCheckpointerAdapter(BaseCheckpointSaver):
             "Please implement adelete_thread in your custom checkpointer to support thread deletion."
         )
 
-    async def aget_tuple(self, config: RunnableConfig) -> CheckpointTuple | None:
-        # Use cached latest_iter if available and matches
-        if self.latest_iter is not None:
-            try:
-                item = await anext(self.latest_iter, None)
-                if item is not None:
-                    item_config = item.config.get("configurable", {})
-                    requested = config.get("configurable", {})
-                    if item_config.get("thread_id") == requested.get(
-                        "thread_id"
-                    ) and item_config.get("checkpoint_ns", "") == requested.get(
-                        "checkpoint_ns", ""
-                    ):
-                        return item
-            finally:
-                self.latest_iter = None
+    async def adelete_for_runs(self, run_ids: Iterable[str]) -> None:
+        if self._capabilities.has_adelete_for_runs:
+            await self._inner.adelete_for_runs(run_ids)
+            return
+        raise RuntimeError(
+            "Please implement adelete_for_runs in your custom checkpointer "
+            "to support run deletion/rollback."
+        )
+
+    async def acopy_thread(self, source_thread_id: str, target_thread_id: str) -> None:
+        if self._capabilities.has_acopy_thread:
+            await self._inner.acopy_thread(source_thread_id, target_thread_id)
+            return
+        raise RuntimeError(
+            "Please implement acopy_thread in your custom checkpointer "
+            "to support thread copy."
+        )
+
+    async def aprune(
+        self, thread_ids: Sequence[str], *, strategy: str = "keep_latest"
+    ) -> None:
+        if self._capabilities.has_aprune:
+            await self._inner.aprune(thread_ids, strategy=strategy)
+            return
+        raise RuntimeError(
+            "Please implement aprune in your custom checkpointer "
+            "to support thread pruning."
+        )
 
+    async def aget_tuple(self, config: RunnableConfig) -> CheckpointTuple | None:
         return await self._inner.aget_tuple(config)
 
     def get_next_version(self, current: str | None, channel: None) -> str:
@@ -180,7 +198,7 @@ async def get_checkpointer(
     use_direct_connection: bool = False,
 ) -> CheckpointerProtocol:
     global _CHECKPOINTER_CAPABILITIES
-    if CUSTOM_CHECKPOINTER:
+    if CUSTOM_CHECKPOINTER is not None:
         # Get or create the inner checkpointer (cached per-thread)
         if not hasattr(CHECKPOINTER_STACK, "inner"):
             stack = AsyncExitStack()
@@ -198,7 +216,7 @@ async def get_checkpointer(
                 f"Using custom checkpointer: {inner}",
                 kind=str(type(inner)),
             )
-        # Create fresh adapter each time (not cached) - each gets own latest_iter
+        # Create a fresh adapter each time (not cached) - each gets own latest_iter
         if _CHECKPOINTER_CAPABILITIES is None:
             raise RuntimeError("Capabilities not initialized")
         return _CustomCheckpointerAdapter(
@@ -212,8 +230,13 @@ async def get_checkpointer(
     )
 
 
+def get_checkpointer_capabilities() -> CheckpointerCapabilities | None:
+    """Return the capabilities of the custom checkpointer, or None if not configured."""
+    return _CHECKPOINTER_CAPABILITIES
+
+
 async def exit_checkpointer() -> None:
-    if not CUSTOM_CHECKPOINTER:
+    if CUSTOM_CHECKPOINTER is None:
         return
     stack = cast("AsyncExitStack|None", getattr(CHECKPOINTER_STACK, "stack", None))
     if stack is None:
@@ -231,8 +254,8 @@ async def collect_checkpointer_from_env() -> None:
 
     await logger.ainfo(
         f"Heads up! You are configuring a custom checkpointer at {checkpointer_path}\n\n"
-        "This checkpointer will be used IN STEAD OF the default persistence backend."
-        "The availability of some functionality, such as TTLs and pruning, may depend on the completion of your implementation."
+        "This checkpointer will be used INSTEAD OF the default persistence backend.\n"
+        "The availability of some functionality, such as TTLs and pruning, may depend on the completion of your implementation.\n"
         "Performance & feature support will depend on the quality of your implementation."
     )
 
@@ -252,7 +275,7 @@ async def collect_checkpointer_from_env() -> None:
 async def _yield_checkpointer(value: Any):
     if isinstance(value, BaseCheckpointSaver):
         yield value
-    # Async ontext manager
+    # Async context manager
     elif hasattr(value, "__aenter__") and hasattr(value, "__aexit__"):
         async with value as ctx_value:
             yield ctx_value
@@ -338,28 +361,64 @@ def _load_checkpointer(checkpointer_path: str) -> Any:
         raise ValueError(
             f"Could not find checkpointer '{checkpointer_path}'. "
             f"Please check that:\n"
-            f"1. The file exports a variable named '{checkpointer_path}'\n"
+            f"1. The file exports a variable named '{function}'\n"
             f"2. The variable name in your config matches the export name{suggestion}"
         ) from e
     return checkpointer
 
 
-def _ensure_run_id(
+# Keys from config["configurable"] that should NOT be copied into checkpoint metadata.
+_EXCLUDED_CONFIGURABLE_KEYS = frozenset({"checkpoint_ns", "checkpoint_id"})
+# Keys that are request-scoped and must not be persisted in checkpoints.
+_TRANSIENT_CONFIGURABLE_KEYS = frozenset(
+    {
+        "langgraph_request_id",
+        "langgraph_auth_user",
+        "langgraph_auth_user_id",
+        "langgraph_auth_permissions",
+    }
+)
+
+
+def _enrich_metadata(
     metadata: CheckpointMetadata, config: RunnableConfig
 ) -> CheckpointMetadata:
-    run_id = metadata.get("run_id")
-    if run_id:
-        return metadata
-    run_id = config.get("run_id")
-    if run_id:
-        return {**metadata, "run_id": run_id}
-    run_id = config.get("metadata", {}).get("run_id")
-    if run_id:
-        return {**metadata, "run_id": run_id}
-    run_id = config["configurable"].get("run_id")
-    if run_id:
-        return {**metadata, "run_id": run_id}
-    raise RuntimeError("Could not find run_id in config")
+    """Enrich checkpoint metadata with config fields.
+
+    Mirrors the metadata enrichment performed by the built-in checkpointers
+    so that downstream consumers (API, state endpoints, copy) see a
+    consistent metadata shape regardless of checkpointer implementation.
+    """
+    configurable = config.get("configurable", {})
+    config_metadata = config.get("metadata", {})
+    enriched: dict = {
+        # 1. Non-internal configurable keys (thread_id, graph_id, etc.)
+        **{
+            k: v
+            for k, v in configurable.items()
+            if not k.startswith("__")
+            and k not in _EXCLUDED_CONFIGURABLE_KEYS
+            and k not in _TRANSIENT_CONFIGURABLE_KEYS
+        },
+        # 2. Config metadata (assistant_id, model_name, etc.)
+        **{
+            k: v
+            for k, v in config_metadata.items()
+            if k not in _TRANSIENT_CONFIGURABLE_KEYS
+        },
+        # 3. Original metadata on top (source, step, parents, etc.)
+        **{k: v for k, v in metadata.items() if k not in _TRANSIENT_CONFIGURABLE_KEYS},
+    }
+    # Ensure run_id is present when available (not always set, e.g. state updates)
+    if not enriched.get("run_id"):
+        run_id = (
+            config.get("run_id")
+            or config_metadata.get("run_id")
+            or configurable.get("run_id")
+        )
+        if run_id:
+            enriched["run_id"] = run_id
+    return enriched
 
 
 def _validate_required_methods(inner: BaseCheckpointSaver):
@@ -381,3 +440,8 @@ def _is_overridden(inner_type: type, method: str) -> bool:
     if base is None or impl is None:
         return impl is not None
     return impl is not base
+
+
+def _has_method(inner_type: type, method: str) -> bool:
+    """Check if a type has a callable method (for methods not on BaseCheckpointSaver)."""
+    return callable(getattr(inner_type, method, None))

{langgraph_api-0.7.31 → langgraph_api-0.7.33}/langgraph_api/_checkpointer/protocol.py

@@ -83,6 +83,11 @@ class CheckpointerProtocol(Protocol):
     ) -> None: ...
 
     async def adelete_thread(self, thread_id: str) -> None: ...
+
+    # NOTE: adelete_for_runs, acopy_thread, and aprune are optional extended
+    # capabilities checked at runtime via CheckpointerCapabilities. They are
+    # NOT part of this protocol to avoid breaking isinstance checks.
+
     async def aget_iter(
         self, config: RunnableConfig
     ) -> AsyncIterator[CheckpointTuple]: ...

{langgraph_api-0.7.31 → langgraph_api-0.7.33}/langgraph_api/api/a2a.py

@@ -661,7 +661,7 @@ def _map_runs_create_error_to_rpc(
     return {
         "error": {
             "code": ERROR_CODE_INTERNAL_ERROR,
-            "message": f"Internal server error: {exception!s}",
+            "message": "Internal server error",
         }
     }
 
@@ -717,7 +717,7 @@ def _map_runs_get_error_to_rpc(
     return {
         "error": {
             "code": ERROR_CODE_INTERNAL_ERROR,
-            "message": f"Internal server error: {exception!s}",
+            "message": "Internal server error",
         }
     }
 
@@ -1287,12 +1287,12 @@ async def handle_message_send(
             assistant_id=assistant_id,
         )
 
-    except Exception as e:
+    except Exception:
         logger.exception(f"Error in message/send for assistant {assistant_id}")
         return {
             "error": {
                 "code": ERROR_CODE_INTERNAL_ERROR,
-                "message": f"Internal server error: {e!s}",
+                "message": "Internal server error",
             }
         }
 
@@ -1488,7 +1488,7 @@ async def handle_tasks_get(
         return {
             "error": {
                 "code": ERROR_CODE_INTERNAL_ERROR,
-                "message": f"Internal server error: {e!s}",
+                "message": "Internal server error",
             }
         }
 
@@ -1654,12 +1654,12 @@ async def handle_get_extended_card(
                 "message": str(e),
             }
         }
-    except Exception as e:
+    except Exception:
         logger.exception(f"Error generating extended agent card for {assistant_id}")
         return {
             "error": {
                 "code": ERROR_CODE_INTERNAL_ERROR,
-                "message": f"Internal server error: {e!s}",
+                "message": "Internal server error",
             }
         }
 
@@ -1806,12 +1806,12 @@ async def handle_agent_card_endpoint(request: ApiRequest) -> Response:
             status_code=400,
             media_type="application/json",
         )
-    except Exception as e:
+    except Exception:
         logger.exception("Failed to generate agent card")
         error_response = {
             "error": {
                 "code": ERROR_CODE_INTERNAL_ERROR,
-                "message": f"Internal server error: {e!s}",
+                "message": "Internal server error",
             }
         }
         return Response(
@@ -2209,7 +2209,7 @@ async def handle_message_stream(
                     "id": rpc_id,
                     "error": {
                         "code": ERROR_CODE_INTERNAL_ERROR,
-                        "message": f"Internal server error: {e!s}",
+                        "message": "Internal server error",
                     },
                 },
             )
@@ -2300,12 +2300,12 @@ async def handle_assistant_agent_card_endpoint(request: ApiRequest) -> Response:
             status_code=400,
             media_type="application/json",
         )
-    except Exception as e:
+    except Exception:
         logger.exception("Failed to generate agent card")
         error_response = {
             "error": {
                 "code": ERROR_CODE_INTERNAL_ERROR,
-                "message": f"Internal server error: {e!s}",
+                "message": "Internal server error",
             }
         }
         return Response(

{langgraph_api-0.7.31 → langgraph_api-0.7.33}/langgraph_api/api/runs.py

@@ -10,12 +10,16 @@ from starlette.responses import Response, StreamingResponse
 
 from langgraph_api import config
 from langgraph_api.asyncio import ValueEvent
+from langgraph_api.encryption.context import get_encryption_context
 from langgraph_api.encryption.middleware import (
     decrypt_response,
     decrypt_responses,
     encrypt_request,
 )
-from langgraph_api.encryption.shared import using_aes_encryption
+from langgraph_api.encryption.shared import (
+    BLOB_ENCRYPTION_CONTEXT_KEY,
+    using_aes_encryption,
+)
 from langgraph_api.feature_flags import IS_POSTGRES_OR_GRPC_BACKEND
 from langgraph_api.graph import _validate_assistant_id
 from langgraph_api.models.run import create_valid_run
@@ -62,6 +66,29 @@ else:
 logger = structlog.stdlib.get_logger(__name__)
 
 
+def parse_stream_mode_param(stream_mode_param: str | None) -> list[str]:
+    """Parse stream_mode query parameter. We use this to support the query param format used by the SDK.
+
+    Supports:
+    - Single values: "values" -> ["values"]
+    - JSON arrays: '["values","messages-tuple","updates"]' -> ["values", "messages-tuple", "updates"]
+    - Empty/None: None -> []
+    """
+    if not stream_mode_param:
+        return []
+
+    # Try to parse as JSON array first
+    if stream_mode_param.startswith("["):
+        try:
+            parsed = orjson.loads(stream_mode_param)
+            if isinstance(parsed, list):
+                return parsed
+        except (orjson.JSONDecodeError, ValueError):
+            pass
+    # Single value
+    return [stream_mode_param]
+
+
 # Type alias for stream handlers (GrpcStreamHandler or ContextQueue).
 # Runs is selected at runtime, and the implementations have different
 # type signatures, so we use Any for compatibility.
@@ -539,7 +566,10 @@ async def join_run_stream(request: ApiRequest):
     cancel_on_disconnect = cancel_on_disconnect_str.lower() in {"true", "yes", "1"}
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     validate_uuid(run_id, "Invalid run ID: must be a UUID")
-    stream_mode = request.query_params.get("stream_mode") or []
+
+    stream_mode_param = request.query_params.get("stream_mode")
+    stream_mode = parse_stream_mode_param(stream_mode_param)
+
     last_event_id = request.headers.get("last-event-id") or None
 
     async def body():
@@ -688,8 +718,16 @@ async def create_cron(request: ApiRequest):
         await validate_webhook_url_or_raise(str(webhook))
     _validate_assistant_id(payload.get("assistant_id"))
 
+    # Store encryption context at payload root so cron scheduler can extract it
+    # regardless of which fields (metadata, input, config, context) are present.
+    # Use a separate variable to avoid shadowing the typed payload.
+    enc_ctx = get_encryption_context()
+    payload_for_encryption: dict = (
+        {**payload, BLOB_ENCRYPTION_CONTEXT_KEY: enc_ctx} if enc_ctx else payload
+    )
+
     encrypted_payload = await encrypt_request(
-        payload,
+        payload_for_encryption,
         "cron",
         CRON_PAYLOAD_ENCRYPTION_SUBFIELDS,
     )
@@ -724,8 +762,16 @@ async def create_thread_cron(request: ApiRequest):
         await validate_webhook_url_or_raise(str(webhook))
     _validate_assistant_id(payload.get("assistant_id"))
 
+    # Store encryption context at payload root so cron scheduler can extract it
+    # regardless of which fields (metadata, input, config, context) are present.
+    # Use a separate variable to avoid shadowing the typed payload.
+    enc_ctx = get_encryption_context()
+    payload_for_encryption: dict = (
+        {**payload, BLOB_ENCRYPTION_CONTEXT_KEY: enc_ctx} if enc_ctx else payload
+    )
+
     encrypted_payload = await encrypt_request(
-        payload,
+        payload_for_encryption,
         "cron",
         CRON_PAYLOAD_ENCRYPTION_SUBFIELDS,
     )

{langgraph_api-0.7.31 → langgraph_api-0.7.33}/langgraph_api/api/store.py

@@ -65,7 +65,7 @@ async def put_item(request: ApiRequest):
     }
     await handle_event("put", handler_payload)
     await (await get_store()).aput(
-        namespace, handler_payload["key"], handler_payload["value"]
+        handler_payload["namespace"], handler_payload["key"], handler_payload["value"]
     )
     return Response(status_code=204)
 

{langgraph_api-0.7.31 → langgraph_api-0.7.33}/langgraph_api/api/ui.py

@@ -68,9 +68,10 @@ async def handle_ui(request: ApiRequest) -> Response:
                 f'<link rel="stylesheet" href="{protocol}//{host}/ui/{graph_id}/{basename}" />'
             )
         elif ext == ".js":
+            safe_name = json.dumps(message["name"]).replace("'", "&#39;")
             result.append(
                 f'<script src="{protocol}//{host}/ui/{graph_id}/{basename}" '
-                f"onload='__LGUI_{valid_js_name}.render({json.dumps(message['name'])}, \"{{{{shadowRootId}}}}\")'>"
+                f"onload='__LGUI_{valid_js_name}.render({safe_name}, \"{{{{shadowRootId}}}}\")'>"
                 "</script>"
             )
 

{langgraph_api-0.7.31 → langgraph_api-0.7.33}/langgraph_api/auth/custom.py

@@ -517,10 +517,10 @@ class ProxyUser(BaseUser):
         }
 
     def __contains__(self, key: str) -> bool:
-        return key in self._user
+        return key in self.dict()
 
     def __getitem__(self, key):
-        return self._user[key]
+        return self.dict()[key]
 
     def __setitem__(self, key, value):
         self._user[key] = value
@@ -530,10 +530,22 @@ class ProxyUser(BaseUser):
         return getattr(self._user, name)
 
     def __iter__(self):
-        return iter(self._user)
+        return iter(self.dict())
 
     def __len__(self):
-        return len(self._user)
+        return len(self.dict())
+
+    def get(self, key, /, default=None):
+        return self.dict().get(key, default)
+
+    def keys(self):
+        return self.dict().keys()
+
+    def values(self):
+        return self.dict().values()
+
+    def items(self):
+        return self.dict().items()
 
     def __str__(self) -> str:
         return f"{self._user}"

langgraph_api-0.7.33/langgraph_api/auth/noop.py

@@ -0,0 +1,53 @@
+from starlette.authentication import (
+    AuthCredentials,
+    AuthenticationBackend,
+    BaseUser,
+)
+from starlette.authentication import (
+    UnauthenticatedUser as StarletteUnauthenticatedUser,
+)
+from starlette.requests import HTTPConnection
+
+
+class UnauthenticatedUser(StarletteUnauthenticatedUser):
+    @property
+    def identity(self) -> str:
+        return ""
+
+    def dict(self):
+        return {
+            "identity": self.identity,
+            "is_authenticated": self.is_authenticated,
+            "display_name": self.display_name,
+        }
+
+    def __getitem__(self, key):
+        return self.dict()[key]
+
+    def __contains__(self, key):
+        return key in self.dict()
+
+    def __iter__(self):
+        return iter(self.dict())
+
+    def __len__(self):
+        return len(self.dict())
+
+    def get(self, key, /, default=None):
+        return self.dict().get(key, default)
+
+    def keys(self):
+        return self.dict().keys()
+
+    def values(self):
+        return self.dict().values()
+
+    def items(self):
+        return self.dict().items()
+
+
+class NoopAuthBackend(AuthenticationBackend):
+    async def authenticate(
+        self, conn: HTTPConnection
+    ) -> tuple[AuthCredentials, BaseUser] | None:
+        return AuthCredentials(), UnauthenticatedUser()

langgraph_api-0.7.33/langgraph_api/auth/studio_user.py

@@ -0,0 +1,39 @@
+from langgraph_sdk.auth.types import StudioUser as StudioUserBase
+from starlette.authentication import BaseUser
+
+
+class StudioUser(StudioUserBase, BaseUser):
+    """StudioUser class."""
+
+    def dict(self):
+        return {
+            "kind": "StudioUser",
+            "is_authenticated": self.is_authenticated,
+            "display_name": self.display_name,
+            "identity": self.identity,
+            "permissions": self.permissions,
+        }
+
+    def __getitem__(self, key):
+        return self.dict()[key]
+
+    def __contains__(self, key):
+        return key in self.dict()
+
+    def __iter__(self):
+        return iter(self.dict())
+
+    def __len__(self):
+        return len(self.dict())
+
+    def get(self, key, /, default=None):
+        return self.dict().get(key, default)
+
+    def keys(self):
+        return self.dict().keys()
+
+    def values(self):
+        return self.dict().values()
+
+    def items(self):
+        return self.dict().items()

{langgraph_api-0.7.31 → langgraph_api-0.7.33}/langgraph_api/cli.py

@@ -107,6 +107,7 @@ def run_server(
     ui: dict | None = None,
     webhooks: dict | None = None,
     ui_config: dict | None = None,
+    checkpointer: dict | None = None,
     studio_url: str | None = None,
     disable_persistence: bool = False,
     allow_blocking: bool = False,
@@ -209,6 +210,7 @@ def run_server(
         LANGGRAPH_UI=json.dumps(ui) if ui else None,
         LANGGRAPH_WEBHOOKS=json.dumps(webhooks) if webhooks else None,
         LANGGRAPH_UI_CONFIG=json.dumps(ui_config) if ui_config else None,
+        LANGGRAPH_CHECKPOINTER=json.dumps(checkpointer) if checkpointer else None,
         LANGGRAPH_UI_BUNDLER="true",
         LANGGRAPH_API_URL=local_url,
         LANGGRAPH_DISABLE_FILE_PERSISTENCE=str(disable_persistence).lower(),
@@ -411,6 +413,7 @@ def main():
     ui = config_data.get("ui")
     webhooks = config_data.get("webhooks")
     ui_config = config_data.get("ui_config")
+    checkpointer = config_data.get("checkpointer")
     kwargs = {}
     if args.runtime_edition == "postgres":
         kwargs["__redis_uri__"] = os.getenv("REDIS_URI")
@@ -433,6 +436,7 @@ def main():
         ui=ui,
         webhooks=webhooks,
         ui_config=ui_config,
+        checkpointer=checkpointer,
         runtime_edition=args.runtime_edition,
         **kwargs,
     )