langgraph-api 0.4.1__py3-none-any.whl → 0.7.3__py3-none-any.whl

langgraph_api/grpc/client.py

@@ -0,0 +1,313 @@
+"""gRPC client wrapper for LangGraph persistence services."""
+
+import asyncio
+import threading
+import time
+
+import structlog
+from grpc import aio  # type: ignore[import]
+from grpc_health.v1 import health_pb2, health_pb2_grpc  # type: ignore[import]
+
+from langgraph_api import config
+
+from .generated.checkpointer_pb2_grpc import CheckpointerStub
+from .generated.core_api_pb2_grpc import (
+    AdminStub,
+    AssistantsStub,
+    RunsStub,
+    ThreadsStub,
+)
+
+logger = structlog.stdlib.get_logger(__name__)
+
+
+# Shared gRPC client pools (main thread + thread-local for isolated loops).
+_client_pool: "GrpcClientPool | None" = None
+_thread_local = threading.local()
+
+
+GRPC_HEALTHCHECK_TIMEOUT = 5.0
+GRPC_INIT_TIMEOUT = 10.0
+GRPC_INIT_PROBE_INTERVAL = 0.5
+
+
+class GrpcClient:
+    """gRPC client for LangGraph persistence services."""
+
+    def __init__(
+        self,
+        server_address: str | None = None,
+    ):
+        """Initialize the gRPC client.
+
+        Args:
+            server_address: The gRPC server address (default: localhost:50051)
+        """
+        self.server_address = server_address or config.GRPC_SERVER_ADDRESS
+        self._channel: aio.Channel | None = None
+        self._assistants_stub: AssistantsStub | None = None
+        self._runs_stub: RunsStub | None = None
+        self._threads_stub: ThreadsStub | None = None
+        self._admin_stub: AdminStub | None = None
+        self._checkpointer_stub: CheckpointerStub | None = None
+        self._health_stub: health_pb2_grpc.HealthStub | None = None
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.close()
+
+    async def connect(self):
+        """Connect to the gRPC server."""
+        if self._channel is not None:
+            return
+
+        options = [
+            ("grpc.max_receive_message_length", config.GRPC_CLIENT_MAX_RECV_MSG_BYTES),
+            ("grpc.max_send_message_length", config.GRPC_CLIENT_MAX_SEND_MSG_BYTES),
+        ]
+
+        self._channel = aio.insecure_channel(self.server_address, options=options)
+
+        self._assistants_stub = AssistantsStub(self._channel)
+        self._runs_stub = RunsStub(self._channel)
+        self._threads_stub = ThreadsStub(self._channel)
+        self._admin_stub = AdminStub(self._channel)
+        self._checkpointer_stub = CheckpointerStub(self._channel)
+        self._health_stub = health_pb2_grpc.HealthStub(self._channel)
+
+        await logger.adebug(
+            "Connected to gRPC server", server_address=self.server_address
+        )
+
+    async def close(self):
+        """Close the gRPC connection."""
+        if self._channel is not None:
+            await self._channel.close()
+            self._channel = None
+            self._assistants_stub = None
+            self._runs_stub = None
+            self._threads_stub = None
+            self._admin_stub = None
+            self._checkpointer_stub = None
+            self._health_stub = None
+            await logger.adebug("Closed gRPC connection")
+
+    async def healthcheck(self) -> bool:
+        """Check if the gRPC server is healthy.
+
+        Returns:
+            True if the server is healthy and serving.
+
+        Raises:
+            RuntimeError: If the client is not connected or the server is unhealthy.
+        """
+        if self._health_stub is None:
+            raise RuntimeError(
+                "Client not connected. Use async context manager or call connect() first."
+            )
+
+        request = health_pb2.HealthCheckRequest(service="")
+        response = await self._health_stub.Check(
+            request, timeout=GRPC_HEALTHCHECK_TIMEOUT
+        )
+
+        if response.status != health_pb2.HealthCheckResponse.SERVING:
+            raise RuntimeError(f"gRPC server is not healthy. Status: {response.status}")
+
+        return True
+
+    @property
+    def assistants(self) -> AssistantsStub:
+        """Get the assistants service stub."""
+        if self._assistants_stub is None:
+            raise RuntimeError(
+                "Client not connected. Use async context manager or call connect() first."
+            )
+        return self._assistants_stub
+
+    @property
+    def threads(self) -> ThreadsStub:
+        """Get the threads service stub."""
+        if self._threads_stub is None:
+            raise RuntimeError(
+                "Client not connected. Use async context manager or call connect() first."
+            )
+        return self._threads_stub
+
+    @property
+    def runs(self) -> RunsStub:
+        """Get the runs service stub."""
+        if self._runs_stub is None:
+            raise RuntimeError(
+                "Client not connected. Use async context manager or call connect() first."
+            )
+        return self._runs_stub
+
+    @property
+    def admin(self) -> AdminStub:
+        """Get the admin service stub."""
+        if self._admin_stub is None:
+            raise RuntimeError(
+                "Client not connected. Use async context manager or call connect() first."
+            )
+        return self._admin_stub
+
+    @property
+    def checkpointer(self) -> CheckpointerStub:
+        """Get the checkpointer service stub."""
+        if self._checkpointer_stub is None:
+            raise RuntimeError(
+                "Client not connected. Use async context manager or call connect() first."
+            )
+        return self._checkpointer_stub
+
+
+class GrpcClientPool:
+    """Pool of gRPC clients for load distribution."""
+
+    def __init__(self, pool_size: int = 5, server_address: str | None = None):
+        self.pool_size = pool_size
+        self.server_address = server_address
+        self.clients: list[GrpcClient] = []
+        self._current_index = 0
+        self._init_lock = asyncio.Lock()
+        self._initialized = False
+
+    async def _initialize(self):
+        """Initialize the pool of clients."""
+        async with self._init_lock:
+            if self._initialized:
+                return
+
+            await logger.ainfo(
+                "Initializing gRPC client pool",
+                pool_size=self.pool_size,
+                server_address=self.server_address,
+            )
+
+            for _ in range(self.pool_size):
+                client = GrpcClient(server_address=self.server_address)
+                await client.connect()
+                self.clients.append(client)
+
+            self._initialized = True
+            await logger.ainfo(
+                f"gRPC client pool initialized with {self.pool_size} clients"
+            )
+
+    async def get_client(self) -> GrpcClient:
+        """Get next client using round-robin selection.
+
+        Round-robin without strict locking - slight races are acceptable
+        and result in good enough distribution under high load.
+        """
+        if not self._initialized:
+            await self._initialize()
+
+        idx = self._current_index % self.pool_size
+        self._current_index = idx + 1
+        return self.clients[idx]
+
+    async def close(self):
+        """Close all clients in the pool."""
+        if self._initialized:
+            await logger.ainfo(f"Closing gRPC client pool ({self.pool_size} clients)")
+            for client in self.clients:
+                await client.close()
+            self.clients.clear()
+            self._initialized = False
+
+
+async def get_shared_client() -> GrpcClient:
+    """Get a gRPC client from the shared pool.
+
+    Uses a pool of channels for better performance under high concurrency.
+    Each channel is a separate TCP connection that can handle ~100-200
+    concurrent streams effectively. Pools are scoped per thread/loop to
+    avoid cross-loop gRPC channel usage.
+
+    Returns:
+        A GrpcClient instance from the pool
+    """
+    if threading.current_thread() is not threading.main_thread():
+        pool = getattr(_thread_local, "grpc_pool", None)
+        if pool is None:
+            pool = GrpcClientPool(
+                pool_size=1,
+                server_address=config.GRPC_SERVER_ADDRESS,
+            )
+            _thread_local.grpc_pool = pool
+        return await pool.get_client()
+
+    global _client_pool
+    if _client_pool is None:
+        _client_pool = GrpcClientPool(
+            pool_size=config.GRPC_CLIENT_POOL_SIZE,
+            server_address=config.GRPC_SERVER_ADDRESS,
+        )
+    return await _client_pool.get_client()
+
+
+async def wait_until_grpc_ready(
+    timeout_seconds: float = GRPC_INIT_TIMEOUT,
+    interval_seconds: float = GRPC_INIT_PROBE_INTERVAL,
+):
+    """Wait for the gRPC server to be ready with retries during startup.
+
+    Args:
+        timeout_seconds: Maximum time to wait for the server to be ready.
+        interval_seconds: Time to wait between health check attempts.
+    Raises:
+        RuntimeError: If the server is not ready within the timeout period.
+    """
+    client = await get_shared_client()
+    max_attempts = int(timeout_seconds / interval_seconds)
+
+    await logger.ainfo(
+        "Waiting for gRPC server to be ready",
+        timeout_seconds=timeout_seconds,
+        interval_seconds=interval_seconds,
+        max_attempts=max_attempts,
+    )
+    start_time = time.time()
+    for attempt in range(max_attempts):
+        try:
+            await client.healthcheck()
+            await logger.ainfo(
+                "gRPC server is ready",
+                attempt=attempt + 1,
+                elapsed_seconds=round(time.time() - start_time, 3),
+            )
+            return
+        except Exception as exc:
+            if attempt >= max_attempts - 1:
+                raise RuntimeError(
+                    f"gRPC server not ready after {timeout_seconds}s (reached max attempts: {max_attempts})"
+                ) from exc
+            else:
+                await logger.adebug(
+                    "Waiting for gRPC server to be ready",
+                    attempt=attempt + 1,
+                    max_attempts=max_attempts,
+                )
+                await asyncio.sleep(interval_seconds)
+
+
+async def close_shared_client():
+    """Close the shared gRPC client pool."""
+    if threading.current_thread() is not threading.main_thread():
+        pool = getattr(_thread_local, "grpc_pool", None)
+        if pool is not None:
+            await pool.close()
+            delattr(_thread_local, "grpc_pool")
+        return
+
+    global _client_pool
+    if _client_pool is not None:
+        await _client_pool.close()
+        _client_pool = None

langgraph_api/grpc/config_conversion.py

@@ -0,0 +1,231 @@
+"""Conversion utils for the RunnableConfig."""
+
+# THIS IS DUPLICATED
+# TODO: WFH - Deduplicate with the executor logic by moving into a separate package
+# Sequencing in the next PR.
+from typing import Any, cast
+
+import orjson
+from langchain_core.runnables.config import RunnableConfig
+
+from langgraph_api.grpc.generated import (
+    engine_common_pb2,
+    enum_durability_pb2,
+)
+
+CONFIG_KEY_SEND = "__pregel_send"
+CONFIG_KEY_READ = "__pregel_read"
+CONFIG_KEY_RESUMING = "__pregel_resuming"
+CONFIG_KEY_TASK_ID = "__pregel_task_id"
+CONFIG_KEY_THREAD_ID = "thread_id"
+CONFIG_KEY_CHECKPOINT_MAP = "checkpoint_map"
+CONFIG_KEY_CHECKPOINT_ID = "checkpoint_id"
+CONFIG_KEY_CHECKPOINT_NS = "checkpoint_ns"
+CONFIG_KEY_SCRATCHPAD = "__pregel_scratchpad"
+CONFIG_KEY_DURABILITY = "__pregel_durability"
+CONFIG_KEY_GRAPH_ID = "graph_id"
+
+
+def _durability_to_proto(
+    durability: str,
+) -> enum_durability_pb2.Durability:
+    match durability:
+        case "async":
+            return enum_durability_pb2.Durability.ASYNC
+        case "sync":
+            return enum_durability_pb2.Durability.SYNC
+        case "exit":
+            return enum_durability_pb2.Durability.EXIT
+        case _:
+            raise ValueError(f"invalid durability: {durability}")
+
+
+def _durability_from_proto(
+    durability: enum_durability_pb2.Durability,
+) -> str:
+    match durability:
+        case enum_durability_pb2.Durability.ASYNC:
+            return "async"
+        case enum_durability_pb2.Durability.SYNC:
+            return "sync"
+        case enum_durability_pb2.Durability.EXIT:
+            return "exit"
+        case _:
+            raise ValueError(f"invalid durability: {durability}")
+
+
+def config_to_proto(
+    config: RunnableConfig,
+) -> engine_common_pb2.EngineRunnableConfig | None:
+    # Prepare kwargs for construction
+    if not config:
+        return None
+    cp = {**config}
+    pb_config = engine_common_pb2.EngineRunnableConfig()
+    for k, v in (cp.pop("metadata", None) or {}).items():
+        if k == "run_attempt":
+            pb_config.run_attempt = v
+        elif k == "run_id":
+            pb_config.server_run_id = str(v)
+        else:
+            pb_config.metadata_json[k] = orjson.dumps(v)
+    if run_name := cp.pop("run_name", None):
+        pb_config.run_name = run_name
+
+    if run_id := cp.pop("run_id", None):
+        pb_config.run_id = str(run_id)
+
+    if (max_concurrency := cp.pop("max_concurrency", None)) and isinstance(
+        max_concurrency, int
+    ):
+        pb_config.max_concurrency = max_concurrency
+
+    if (recursion_limit := cp.pop("recursion_limit", None)) and isinstance(
+        recursion_limit, int
+    ):
+        pb_config.recursion_limit = recursion_limit
+
+    # Handle collections after construction
+    if (tags := cp.pop("tags", None)) and isinstance(tags, list):
+        pb_config.tags.extend(tags)
+
+    if (configurable := cp.pop("configurable", None)) and isinstance(
+        configurable, dict
+    ):
+        _inject_configurable_into_proto(configurable, pb_config)
+    if cp:
+        pb_config.extra_json.update({k: orjson.dumps(v) for k, v in cp.items()})
+
+    return pb_config
+
+
+RESTRICTED_RESERVED_CONFIGURABLE_KEYS = {
+    CONFIG_KEY_SEND,
+    CONFIG_KEY_READ,
+    CONFIG_KEY_SCRATCHPAD,
+}
+
+
+def _inject_configurable_into_proto(
+    configurable: dict[str, Any], proto: engine_common_pb2.EngineRunnableConfig
+) -> None:
+    extra = {}
+    for key, value in configurable.items():
+        if key == CONFIG_KEY_RESUMING:
+            proto.resuming = bool(value)
+        elif key == CONFIG_KEY_TASK_ID:
+            proto.task_id = str(value)
+        elif key == CONFIG_KEY_THREAD_ID:
+            proto.thread_id = str(value)
+        elif key == CONFIG_KEY_CHECKPOINT_MAP:
+            proto.checkpoint_map.update(cast("dict[str, str]", value))
+        elif key == CONFIG_KEY_CHECKPOINT_ID:
+            proto.checkpoint_id = str(value)
+        elif key == CONFIG_KEY_CHECKPOINT_NS:
+            proto.checkpoint_ns = str(value)
+        elif key == CONFIG_KEY_DURABILITY and value:
+            proto.durability = _durability_to_proto(value)
+        elif key not in RESTRICTED_RESERVED_CONFIGURABLE_KEYS:
+            extra[key] = value
+    if extra:
+        proto.extra_configurable_json.update(
+            {k: orjson.dumps(v) for k, v in extra.items()}
+        )
+
+
+def context_to_json_bytes(context: dict[str, Any] | Any) -> bytes | None:
+    """Convert context to JSON bytes for proto serialization."""
+    if context is None:
+        return None
+
+    # Convert dataclass or other objects to dict if needed
+    if hasattr(context, "__dict__") and not hasattr(context, "items"):
+        # Convert dataclass to dict
+        context_dict = context.__dict__
+    elif hasattr(context, "items"):
+        # Already a dict-like object
+        context_dict = dict(context)
+    else:
+        # Try to convert to dict using vars()
+        context_dict = vars(context) if hasattr(context, "__dict__") else {}
+
+    return orjson.dumps(context_dict)
+
+
+def config_from_proto(
+    config_proto: engine_common_pb2.EngineRunnableConfig | None,
+) -> RunnableConfig:
+    if not config_proto:
+        return RunnableConfig(tags=[], metadata={}, configurable={})
+
+    configurable = _configurable_from_proto(config_proto)
+
+    metadata = {}
+    for k, v in config_proto.metadata_json.items():
+        metadata[k] = orjson.loads(v)
+    if config_proto.HasField("run_attempt"):
+        metadata["run_attempt"] = config_proto.run_attempt
+    if config_proto.HasField("server_run_id"):
+        metadata["run_id"] = config_proto.server_run_id
+
+    config = RunnableConfig()
+    if config_proto.extra_json:
+        for k, v in config_proto.extra_json.items():
+            config[k] = orjson.loads(v)  # type: ignore[invalid-key]
+    if config_proto.tags:
+        config["tags"] = list(config_proto.tags)
+    if metadata:
+        config["metadata"] = metadata
+    if configurable:
+        config["configurable"] = configurable
+    if config_proto.HasField("run_name"):
+        config["run_name"] = config_proto.run_name
+
+    if config_proto.HasField("max_concurrency"):
+        config["max_concurrency"] = config_proto.max_concurrency
+
+    if config_proto.HasField("recursion_limit"):
+        config["recursion_limit"] = config_proto.recursion_limit
+
+    return config
+
+
+def _configurable_from_proto(
+    config_proto: engine_common_pb2.EngineRunnableConfig,
+) -> dict[str, Any]:
+    configurable = {}
+
+    if config_proto.HasField("resuming"):
+        configurable[CONFIG_KEY_RESUMING] = config_proto.resuming
+
+    if config_proto.HasField("task_id"):
+        configurable[CONFIG_KEY_TASK_ID] = config_proto.task_id
+
+    if config_proto.HasField("thread_id"):
+        configurable[CONFIG_KEY_THREAD_ID] = config_proto.thread_id
+
+    if config_proto.HasField("checkpoint_id"):
+        configurable[CONFIG_KEY_CHECKPOINT_ID] = config_proto.checkpoint_id
+
+    if config_proto.HasField("checkpoint_ns"):
+        configurable[CONFIG_KEY_CHECKPOINT_NS] = config_proto.checkpoint_ns
+
+    if config_proto.HasField("durability"):
+        durability = _durability_from_proto(config_proto.durability)
+        if durability:
+            configurable[CONFIG_KEY_DURABILITY] = durability
+
+    if config_proto.HasField("graph_id"):
+        configurable[CONFIG_KEY_GRAPH_ID] = config_proto.graph_id
+
+    if config_proto.HasField("run_id"):
+        configurable["run_id"] = config_proto.run_id
+
+    if len(config_proto.checkpoint_map) > 0:
+        configurable[CONFIG_KEY_CHECKPOINT_MAP] = dict(config_proto.checkpoint_map)
+
+    if len(config_proto.extra_configurable_json) > 0:
+        for k, v in config_proto.extra_configurable_json.items():
+            configurable[k] = orjson.loads(v)
+
+    return configurable

langgraph_api/grpc/generated/__init__.py

@@ -0,0 +1,29 @@
+# Generated protobuf files
+# Import enum files first to avoid circular imports
+from . import enum_cancel_run_action_pb2
+from . import enum_control_signal_pb2
+from . import enum_durability_pb2
+from . import enum_multitask_strategy_pb2
+from . import enum_run_status_pb2
+from . import enum_stream_mode_pb2
+from . import enum_thread_status_pb2
+from . import enum_thread_stream_mode_pb2
+from . import core_api_pb2
+from . import core_api_pb2_grpc
+from . import checkpointer_pb2
+from . import checkpointer_pb2_grpc
+
+__all__ = [
+    "core_api_pb2",
+    "core_api_pb2_grpc",
+    "checkpointer_pb2",
+    "checkpointer_pb2_grpc",
+    "enum_cancel_run_action_pb2",
+    "enum_control_signal_pb2",
+    "enum_durability_pb2",
+    "enum_multitask_strategy_pb2",
+    "enum_run_status_pb2",
+    "enum_stream_mode_pb2",
+    "enum_thread_status_pb2",
+    "enum_thread_stream_mode_pb2",
+]

langgraph_api/grpc/generated/checkpointer_pb2.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: checkpointer.proto
+# Protobuf Python Version: 6.31.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    6,
+    31,
+    1,
+    '',
+    'checkpointer.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2
+from . import engine_common_pb2 as engine__common__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x12\x63heckpointer.proto\x12\x0c\x63heckpointer\x1a\x1bgoogle/protobuf/empty.proto\x1a\x13\x65ngine-common.proto\"\x97\x02\n\nPutRequest\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\".engineCommon.EngineRunnableConfig\x12,\n\ncheckpoint\x18\x02 \x01(\x0b\x32\x18.engineCommon.Checkpoint\x12\x32\n\x08metadata\x18\x03 \x01(\x0b\x32 .engineCommon.CheckpointMetadata\x12?\n\x0cnew_versions\x18\x04 \x03(\x0b\x32).checkpointer.PutRequest.NewVersionsEntry\x1a\x32\n\x10NewVersionsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"\x8f\x01\n\x10PutWritesRequest\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\".engineCommon.EngineRunnableConfig\x12#\n\x06writes\x18\x02 \x03(\x0b\x32\x13.engineCommon.Write\x12\x0f\n\x07task_id\x18\x03 \x01(\t\x12\x11\n\ttask_path\x18\x04 \x01(\t\"\xa8\x01\n\x0bListRequest\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\".engineCommon.EngineRunnableConfig\x12\x13\n\x0b\x66ilter_json\x18\x02 \x01(\x0c\x12\x32\n\x06\x62\x65\x66ore\x18\x03 \x01(\x0b\x32\".engineCommon.EngineRunnableConfig\x12\x12\n\x05limit\x18\x04 \x01(\x03H\x00\x88\x01\x01\x42\x08\n\x06_limit\"(\n\x13\x44\x65leteThreadRequest\x12\x11\n\tthread_id\x18\x01 \x01(\t\"\xa1\x01\n\x0cPruneRequest\x12\x12\n\nthread_ids\x18\x01 \x03(\t\x12:\n\x08strategy\x18\x02 \x01(\x0e\x32(.checkpointer.PruneRequest.PruneStrategy\"A\n\rPruneStrategy\x12\x0f\n\x0bUNSPECIFIED\x10\x00\x12\x0f\n\x0bKEEP_LATEST\x10\x01\x12\x0e\n\nDELETE_ALL\x10\x02\"E\n\x0fGetTupleRequest\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\".engineCommon.EngineRunnableConfig\"F\n\x0bPutResponse\x12\x37\n\x0bnext_config\x18\x01 \x01(\x0b\x32\".engineCommon.EngineRunnableConfig\"H\n\x0cListResponse\x12\x38\n\x11\x63heckpoint_tuples\x18\x01 \x03(\x0b\x32\x1d.engineCommon.CheckpointTuple\"e\n\x10GetTupleResponse\x12<\n\x10\x63heckpoint_tuple\x18\x01 \x01(\x0b\x32\x1d.engineCommon.CheckpointTupleH\x00\x88\x01\x01\x42\x13\n\x11_checkpoint_tuple2\xa1\x03\n\x0c\x43heckpointer\x12:\n\x03Put\x12\x18.checkpointer.PutRequest\x1a\x19.checkpointer.PutResponse\x12\x43\n\tPutWrites\x12\x1e.checkpointer.PutWritesRequest\x1a\x16.google.protobuf.Empty\x12=\n\x04List\x12\x19.checkpointer.ListRequest\x1a\x1a.checkpointer.ListResponse\x12I\n\x08GetTuple\x12\x1d.checkpointer.GetTupleRequest\x1a\x1e.checkpointer.GetTupleResponse\x12I\n\x0c\x44\x65leteThread\x12!.checkpointer.DeleteThreadRequest\x1a\x16.google.protobuf.Empty\x12;\n\x05Prune\x12\x1a.checkpointer.PruneRequest\x1a\x16.google.protobuf.EmptyB?Z=github.com/langchain-ai/langgraph-api/core/internal/engine/pbb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'checkpointer_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  _globals['DESCRIPTOR']._loaded_options = None
+  _globals['DESCRIPTOR']._serialized_options = b'Z=github.com/langchain-ai/langgraph-api/core/internal/engine/pb'
+  _globals['_PUTREQUEST_NEWVERSIONSENTRY']._loaded_options = None
+  _globals['_PUTREQUEST_NEWVERSIONSENTRY']._serialized_options = b'8\001'
+  _globals['_PUTREQUEST']._serialized_start=87
+  _globals['_PUTREQUEST']._serialized_end=366
+  _globals['_PUTREQUEST_NEWVERSIONSENTRY']._serialized_start=316
+  _globals['_PUTREQUEST_NEWVERSIONSENTRY']._serialized_end=366
+  _globals['_PUTWRITESREQUEST']._serialized_start=369
+  _globals['_PUTWRITESREQUEST']._serialized_end=512
+  _globals['_LISTREQUEST']._serialized_start=515
+  _globals['_LISTREQUEST']._serialized_end=683
+  _globals['_DELETETHREADREQUEST']._serialized_start=685
+  _globals['_DELETETHREADREQUEST']._serialized_end=725
+  _globals['_PRUNEREQUEST']._serialized_start=728
+  _globals['_PRUNEREQUEST']._serialized_end=889
+  _globals['_PRUNEREQUEST_PRUNESTRATEGY']._serialized_start=824
+  _globals['_PRUNEREQUEST_PRUNESTRATEGY']._serialized_end=889
+  _globals['_GETTUPLEREQUEST']._serialized_start=891
+  _globals['_GETTUPLEREQUEST']._serialized_end=960
+  _globals['_PUTRESPONSE']._serialized_start=962
+  _globals['_PUTRESPONSE']._serialized_end=1032
+  _globals['_LISTRESPONSE']._serialized_start=1034
+  _globals['_LISTRESPONSE']._serialized_end=1106
+  _globals['_GETTUPLERESPONSE']._serialized_start=1108
+  _globals['_GETTUPLERESPONSE']._serialized_end=1209
+  _globals['_CHECKPOINTER']._serialized_start=1212
+  _globals['_CHECKPOINTER']._serialized_end=1629
+# @@protoc_insertion_point(module_scope)