langgraph-api 0.4.28__py3-none-any.whl → 0.4.29__py3-none-any.whl

langgraph_api/grpc_ops/ops.py

@@ -0,0 +1,540 @@
+"""gRPC-based operations for LangGraph API."""
+
+from __future__ import annotations
+
+import asyncio
+import functools
+from collections.abc import AsyncIterator
+from http import HTTPStatus
+from typing import Any
+from uuid import UUID
+
+import structlog
+from google.protobuf.json_format import MessageToDict
+from google.protobuf.struct_pb2 import Struct  # type: ignore[import]
+from grpc import StatusCode
+from grpc.aio import AioRpcError
+from langgraph_sdk.schema import Config
+from starlette.exceptions import HTTPException
+
+from langgraph_api.schema import (
+    Assistant,
+    AssistantSelectField,
+    Context,
+    MetadataInput,
+    OnConflictBehavior,
+)
+
+from .client import GrpcClient
+from .generated import core_api_pb2 as pb
+
+GRPC_STATUS_TO_HTTP_STATUS = {
+    StatusCode.NOT_FOUND: HTTPStatus.NOT_FOUND,
+    StatusCode.ALREADY_EXISTS: HTTPStatus.CONFLICT,
+    StatusCode.INVALID_ARGUMENT: HTTPStatus.UNPROCESSABLE_ENTITY,
+}
+
+logger = structlog.stdlib.get_logger(__name__)
+
+
+def map_if_exists(if_exists: str) -> pb.OnConflictBehavior:
+    if if_exists == "do_nothing":
+        return pb.OnConflictBehavior.DO_NOTHING
+    return pb.OnConflictBehavior.RAISE
+
+
+def map_configurable(config: Config) -> Struct:
+    return pb.RunnableConfig(
+        tags=config.get("tags", []),
+        recursion_limit=config.get("recursion_limit"),
+        configurable=dict_to_struct(config.get("configurable", {}))
+        if config.get("configurable")
+        else None,
+    )
+
+
+def consolidate_config_and_context(config: Config, context: Context | None):
+    if config and config.get("configurable") and context:
+        raise HTTPException(
+            status_code=400,
+            detail="Cannot specify both configurable and context. Prefer setting context alone. Context was introduced in LangGraph 0.6.0 and is the long term planned replacement for configurable.",
+        )
+
+    # Keep config and context up to date with one another
+    if config and config.get("configurable"):
+        context = config["configurable"]
+    elif context:
+        config["configurable"] = context
+
+
+def dict_to_struct(data: dict[str, Any]) -> Struct:
+    """Convert a dictionary to a protobuf Struct."""
+    struct = Struct()
+    if data:
+        struct.update(data)
+    return struct
+
+
+def struct_to_dict(struct: Struct) -> dict[str, Any]:
+    """Convert a protobuf Struct to a dictionary."""
+    return MessageToDict(struct) if struct else {}
+
+
+def proto_to_assistant(proto_assistant: pb.Assistant) -> Assistant:
+    """Convert protobuf Assistant to dictionary format."""
+    return {
+        "assistant_id": proto_assistant.assistant_id,
+        "graph_id": proto_assistant.graph_id,
+        "version": proto_assistant.version,
+        "created_at": proto_assistant.created_at.ToDatetime(),
+        "updated_at": proto_assistant.updated_at.ToDatetime(),
+        "config": struct_to_dict(proto_assistant.config),
+        "context": struct_to_dict(proto_assistant.context),
+        "metadata": struct_to_dict(proto_assistant.metadata),
+        "name": proto_assistant.name,
+        "description": proto_assistant.description,
+    }
+
+
+def _map_sort_by(sort_by: str | None) -> pb.AssistantsSortBy:
+    """Map string sort_by to protobuf enum."""
+    if not sort_by:
+        return pb.AssistantsSortBy.CREATED_AT
+
+    sort_by_lower = sort_by.lower()
+    mapping = {
+        "assistant_id": pb.AssistantsSortBy.ASSISTANT_ID,
+        "graph_id": pb.AssistantsSortBy.GRAPH_ID,
+        "name": pb.AssistantsSortBy.NAME,
+        "created_at": pb.AssistantsSortBy.CREATED_AT,
+        "updated_at": pb.AssistantsSortBy.UPDATED_AT,
+    }
+    return mapping.get(sort_by_lower, pb.AssistantsSortBy.CREATED_AT)
+
+
+def _map_sort_order(sort_order: str | None) -> pb.SortOrder:
+    """Map string sort_order to protobuf enum."""
+    if sort_order and sort_order.upper() == "ASC":
+        return pb.SortOrder.ASC
+    return pb.SortOrder.DESC
+
+
+def _handle_grpc_error(error: AioRpcError) -> None:
+    """Handle gRPC errors and convert to appropriate exceptions."""
+    raise HTTPException(
+        status_code=GRPC_STATUS_TO_HTTP_STATUS.get(
+            error.code(), HTTPStatus.INTERNAL_SERVER_ERROR
+        ),
+        detail=str(error.details()),
+    )
+
+
+class Authenticated:
+    """Base class for authenticated operations (matches storage_postgres interface)."""
+
+    resource: str = "assistants"
+
+    @classmethod
+    async def handle_event(
+        cls,
+        ctx: Any,  # Auth context
+        action: str,
+        value: Any,
+    ) -> dict[str, Any] | None:
+        """Handle authentication event - stub implementation for now."""
+        # TODO: Implement proper auth handling that converts auth context
+        # to gRPC AuthFilter format when needed
+        return None
+
+
+def grpc_error_guard(cls):
+    """Class decorator to wrap async methods and handle gRPC errors uniformly."""
+    for name, attr in list(cls.__dict__.items()):
+        func = None
+        wrapper_type = None
+        if isinstance(attr, staticmethod):
+            func = attr.__func__
+            wrapper_type = staticmethod
+        elif isinstance(attr, classmethod):
+            func = attr.__func__
+            wrapper_type = classmethod
+        elif callable(attr):
+            func = attr
+
+        if func and asyncio.iscoroutinefunction(func):
+
+            def make_wrapper(f):
+                @functools.wraps(f)
+                async def wrapped(*args, **kwargs):
+                    try:
+                        return await f(*args, **kwargs)
+                    except AioRpcError as e:
+                        _handle_grpc_error(e)
+
+                return wrapped  # noqa: B023
+
+            wrapped = make_wrapper(func)
+            if wrapper_type is staticmethod:
+                setattr(cls, name, staticmethod(wrapped))
+            elif wrapper_type is classmethod:
+                setattr(cls, name, classmethod(wrapped))
+            else:
+                setattr(cls, name, wrapped)
+    return cls
+
+
+@grpc_error_guard
+class Assistants(Authenticated):
+    """gRPC-based assistants operations."""
+
+    resource = "assistants"
+
+    @staticmethod
+    async def search(
+        conn,  # Not used in gRPC implementation
+        *,
+        graph_id: str | None,
+        metadata: MetadataInput,
+        limit: int,
+        offset: int,
+        sort_by: str | None = None,
+        sort_order: str | None = None,
+        select: list[AssistantSelectField] | None = None,
+        ctx: Any = None,
+    ) -> tuple[AsyncIterator[Assistant], int | None]:  # type: ignore[return-value]
+        """Search assistants via gRPC."""
+        # Handle auth filters
+        auth_filters = await Assistants.handle_event(
+            ctx,
+            "search",
+            {
+                "graph_id": graph_id,
+                "metadata": metadata,
+                "limit": limit,
+                "offset": offset,
+            },
+        )
+
+        # Build the gRPC request
+        request = pb.SearchAssistantsRequest(
+            filters=auth_filters,
+            graph_id=graph_id,
+            metadata=dict_to_struct(metadata or {}),
+            limit=limit,
+            offset=offset,
+            sort_by=_map_sort_by(sort_by),
+            sort_order=_map_sort_order(sort_order),
+            select=select,
+        )
+
+        # Make the gRPC call
+        async with GrpcClient() as client:
+            response = await client.assistants.Search(request)
+
+        # Convert response to expected format
+        assistants = [
+            proto_to_assistant(assistant) for assistant in response.assistants
+        ]
+
+        # Determine if there are more results
+        # Note: gRPC doesn't return cursor info, so we estimate based on result count
+        cursor = offset + limit if len(assistants) == limit else None
+
+        async def generate_results():
+            for assistant in assistants:
+                yield {
+                    k: v for k, v in assistant.items() if select is None or k in select
+                }
+
+        return generate_results(), cursor
+
+    @staticmethod
+    async def get(
+        conn,  # Not used in gRPC implementation
+        assistant_id: UUID | str,
+        ctx: Any = None,
+    ) -> AsyncIterator[Assistant]:  # type: ignore[return-value]
+        """Get assistant by ID via gRPC."""
+        # Handle auth filters
+        auth_filters = await Assistants.handle_event(
+            ctx, "read", {"assistant_id": str(assistant_id)}
+        )
+
+        # Build the gRPC request
+        request = pb.GetAssistantRequest(
+            assistant_id=str(assistant_id),
+            filters=auth_filters or {},
+        )
+
+        # Make the gRPC call
+        async with GrpcClient() as client:
+            response = await client.assistants.Get(request)
+
+        # Convert and yield the result
+        assistant = proto_to_assistant(response)
+
+        async def generate_result():
+            yield assistant
+
+        return generate_result()
+
+    @staticmethod
+    async def put(
+        conn,  # Not used in gRPC implementation
+        assistant_id: UUID | str,
+        *,
+        graph_id: str,
+        config: Config,
+        context: Context,
+        metadata: MetadataInput,
+        if_exists: OnConflictBehavior,
+        name: str,
+        description: str | None = None,
+        ctx: Any = None,
+    ) -> AsyncIterator[Assistant]:  # type: ignore[return-value]
+        """Create/update assistant via gRPC."""
+        # Handle auth filters
+        auth_filters = await Assistants.handle_event(
+            ctx,
+            "create",
+            {
+                "assistant_id": str(assistant_id),
+                "graph_id": graph_id,
+                "config": config,
+                "context": context,
+                "metadata": metadata,
+                "name": name,
+                "description": description,
+            },
+        )
+
+        consolidate_config_and_context(config, context)
+
+        on_conflict = map_if_exists(if_exists)
+
+        # Build the gRPC request
+        request = pb.CreateAssistantRequest(
+            assistant_id=str(assistant_id),
+            graph_id=graph_id,
+            filters=auth_filters or {},
+            if_exists=on_conflict,
+            config=map_configurable(config),
+            context=dict_to_struct(context or {}),
+            name=name,
+            description=description,
+            metadata=dict_to_struct(metadata or {}),
+        )
+
+        # Make the gRPC call
+        async with GrpcClient() as client:
+            response = await client.assistants.Create(request)
+
+        # Convert and yield the result
+        assistant = proto_to_assistant(response)
+
+        async def generate_result():
+            yield assistant
+
+        return generate_result()
+
+    @staticmethod
+    async def patch(
+        conn,  # Not used in gRPC implementation
+        assistant_id: UUID | str,
+        *,
+        config: dict | None = None,
+        context: Context | None = None,
+        graph_id: str | None = None,
+        metadata: MetadataInput | None = None,
+        name: str | None = None,
+        description: str | None = None,
+        ctx: Any = None,
+    ) -> AsyncIterator[Assistant]:  # type: ignore[return-value]
+        """Update assistant via gRPC."""
+        metadata = metadata if metadata is not None else {}
+        config = config if config is not None else {}
+        # Handle auth filters
+        auth_filters = await Assistants.handle_event(
+            ctx,
+            "update",
+            {
+                "assistant_id": str(assistant_id),
+                "graph_id": graph_id,
+                "config": config,
+                "context": context,
+                "metadata": metadata,
+                "name": name,
+                "description": description,
+            },
+        )
+
+        consolidate_config_and_context(config, context)
+
+        # Build the gRPC request
+        request = pb.PatchAssistantRequest(
+            assistant_id=str(assistant_id),
+            filters=auth_filters or {},
+            graph_id=graph_id,
+            name=name,
+            description=description,
+            metadata=dict_to_struct(metadata or {}),
+        )
+
+        # Add optional config if provided
+        if config:
+            request.config.CopyFrom(map_configurable(config))
+
+        # Add optional context if provided
+        if context:
+            request.context.CopyFrom(dict_to_struct(context))
+
+        # Make the gRPC call
+        async with GrpcClient() as client:
+            response = await client.assistants.Patch(request)
+
+        # Convert and yield the result
+        assistant = proto_to_assistant(response)
+
+        async def generate_result():
+            yield assistant
+
+        return generate_result()
+
+    @staticmethod
+    async def delete(
+        conn,  # Not used in gRPC implementation
+        assistant_id: UUID | str,
+        ctx: Any = None,
+    ) -> AsyncIterator[UUID]:  # type: ignore[return-value]
+        """Delete assistant via gRPC."""
+        # Handle auth filters
+        auth_filters = await Assistants.handle_event(
+            ctx, "delete", {"assistant_id": str(assistant_id)}
+        )
+
+        # Build the gRPC request
+        request = pb.DeleteAssistantRequest(
+            assistant_id=str(assistant_id),
+            filters=auth_filters or {},
+        )
+
+        # Make the gRPC call
+        async with GrpcClient() as client:
+            await client.assistants.Delete(request)
+
+        # Return the deleted ID
+        async def generate_result():
+            yield UUID(str(assistant_id))
+
+        return generate_result()
+
+    @staticmethod
+    async def set_latest(
+        conn,  # Not used in gRPC implementation
+        assistant_id: UUID | str,
+        version: int,
+        ctx: Any = None,
+    ) -> AsyncIterator[Assistant]:  # type: ignore[return-value]
+        """Set latest version of assistant via gRPC."""
+        # Handle auth filters
+        auth_filters = await Assistants.handle_event(
+            ctx,
+            "update",
+            {
+                "assistant_id": str(assistant_id),
+                "version": version,
+            },
+        )
+
+        # Build the gRPC request
+        request = pb.SetLatestAssistantRequest(
+            assistant_id=str(assistant_id),
+            version=version,
+            filters=auth_filters or {},
+        )
+
+        # Make the gRPC call
+        async with GrpcClient() as client:
+            response = await client.assistants.SetLatest(request)
+
+        # Convert and yield the result
+        assistant = proto_to_assistant(response)
+
+        async def generate_result():
+            yield assistant
+
+        return generate_result()
+
+    @staticmethod
+    async def get_versions(
+        conn,  # Not used in gRPC implementation
+        assistant_id: UUID | str,
+        metadata: MetadataInput,
+        limit: int,
+        offset: int,
+        ctx: Any = None,
+    ) -> AsyncIterator[Assistant]:  # type: ignore[return-value]
+        """Get all versions of assistant via gRPC."""
+        # Handle auth filters
+        auth_filters = await Assistants.handle_event(
+            ctx,
+            "search",
+            {"assistant_id": str(assistant_id), "metadata": metadata},
+        )
+
+        # Build the gRPC request
+        request = pb.GetAssistantVersionsRequest(
+            assistant_id=str(assistant_id),
+            filters=auth_filters or {},
+            metadata=dict_to_struct(metadata or {}),
+            limit=limit,
+            offset=offset,
+        )
+
+        # Make the gRPC call
+        async with GrpcClient() as client:
+            response = await client.assistants.GetVersions(request)
+
+        # Convert and yield the results
+        async def generate_results():
+            for version in response.versions:
+                yield {
+                    "assistant_id": version.assistant_id,
+                    "graph_id": version.graph_id,
+                    "version": version.version,
+                    "created_at": version.created_at.ToDatetime(),
+                    "config": struct_to_dict(version.config),
+                    "context": struct_to_dict(version.context),
+                    "metadata": struct_to_dict(version.metadata),
+                    "name": version.name,
+                    "description": version.description,
+                }
+
+        return generate_results()
+
+    @staticmethod
+    async def count(
+        conn,  # Not used in gRPC implementation
+        *,
+        graph_id: str | None = None,
+        metadata: MetadataInput = None,
+        ctx: Any = None,
+    ) -> int:  # type: ignore[return-value]
+        """Count assistants via gRPC."""
+        # Handle auth filters
+        auth_filters = await Assistants.handle_event(
+            ctx, "search", {"graph_id": graph_id, "metadata": metadata}
+        )
+
+        # Build the gRPC request
+        request = pb.CountAssistantsRequest(
+            filters=auth_filters or {},
+            graph_id=graph_id,
+            metadata=dict_to_struct(metadata or {}),
+        )
+
+        # Make the gRPC call
+        async with GrpcClient() as client:
+            response = await client.assistants.Count(request)
+
+        return int(response.count)

langgraph_api/grpc_ops/scripts/generate_protos.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+# Generate Python protobuf files from core protos
+# Run this from the api/langgraph_api/grpc_ops directory
+
+set -e
+
+# Get the project root (three levels up from api/langgraph_api/grpc_ops)
+PROJECT_ROOT="$(cd ../../../ && pwd)"
+PROTO_DIR="${PROJECT_ROOT}/core/protos"
+OUTPUT_DIR="generated"
+
+# Check if proto file exists
+if [[ ! -f "${PROTO_DIR}/core-api.proto" ]]; then
+    echo "Error: Proto file not found at ${PROTO_DIR}/core-api.proto"
+    exit 1
+fi
+
+# Create output directory if it doesn't exist
+mkdir -p "${OUTPUT_DIR}"
+
+# Generate Python protobuf files
+echo "Generating Python protobuf files..."
+uv run python -m grpc_tools.protoc \
+    -I"${PROTO_DIR}" \
+    --python_out="${OUTPUT_DIR}" \
+    --grpc_python_out="${OUTPUT_DIR}" \
+    --pyi_out="${OUTPUT_DIR}" \
+    "${PROTO_DIR}/core-api.proto"
+
+# Fix imports to be relative in the generated gRPC file
+echo "Fixing imports to be relative..."
+if [[ -f "${OUTPUT_DIR}/core_api_pb2_grpc.py" ]]; then
+    # Make import of core_api_pb2 relative, preserving whatever alias grpc_tools chose
+    sed -i.bak 's/^import core_api_pb2 as /from . import core_api_pb2 as /' "${OUTPUT_DIR}/core_api_pb2_grpc.py"
+    rm -f "${OUTPUT_DIR}/core_api_pb2_grpc.py.bak"
+fi
+
+# Create __init__.py files
+cat > "${OUTPUT_DIR}/__init__.py" << 'EOF'
+# Generated protobuf files
+from . import core_api_pb2
+from . import core_api_pb2_grpc
+
+__all__ = ["core_api_pb2", "core_api_pb2_grpc"]
+EOF
+
+echo "Python protobuf files generated successfully!"

langgraph_api/schema.py

@@ -62,7 +62,7 @@ class Checkpoint(TypedDict):
     checkpoint_map: dict[str, Any] | None
 
 
-class Assistant(TypedDict):
+class Assistant(TypedDict, total=False):
     """Assistant model."""
 
     assistant_id: UUID
@@ -176,6 +176,7 @@ class RunKwargs(TypedDict):
     subgraphs: bool
     resumable: bool
     checkpoint_during: bool
+    durability: str | None
 
 
 class Run(TypedDict):

{langgraph_api-0.4.28.dist-info → langgraph_api-0.4.29.dist-info}/METADATA

@@ -1,12 +1,14 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.4.28
+Version: 0.4.29
 Author-email: Nuno Campos <nuno@langchain.dev>, Will Fu-Hinthorn <will@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE
 Requires-Python: >=3.11
 Requires-Dist: cloudpickle>=3.0.0
 Requires-Dist: cryptography<45.0,>=42.0.0
+Requires-Dist: grpcio-tools<2.0.0,>=1.75.0
+Requires-Dist: grpcio<2.0.0,>=1.75.0
 Requires-Dist: httpx>=0.25.0
 Requires-Dist: jsonschema-rs<0.30,>=0.20.0
 Requires-Dist: langchain-core>=0.3.64
@@ -16,6 +18,7 @@ Requires-Dist: langgraph-sdk>=0.2.0
 Requires-Dist: langgraph>=0.4.0
 Requires-Dist: langsmith>=0.3.45
 Requires-Dist: orjson>=3.9.7
+Requires-Dist: protobuf<7.0.0,>=6.32.1
 Requires-Dist: pyjwt>=2.9.0
 Requires-Dist: sse-starlette<2.2.0,>=2.1.0
 Requires-Dist: starlette>=0.38.6

{langgraph_api-0.4.28.dist-info → langgraph_api-0.4.29.dist-info}/RECORD

@@ -1,4 +1,4 @@
-langgraph_api/__init__.py,sha256=QZ0p7EqvqxpClz_YH3XtlxgPmyXKcK-CGg_B_p5Z7w0,23
+langgraph_api/__init__.py,sha256=LtSKwkqgueDQK6uLnhs8HgKylJHH36EMo48UDeHgv2Y,23
 langgraph_api/asgi_transport.py,sha256=XtiLOu4WWsd-xizagBLzT5xUkxc9ZG9YqwvETBPjBFE,5161
 langgraph_api/asyncio.py,sha256=FEEkLm_N-15cbElo4vQ309MkDKBZuRqAYV8VJ1DocNw,9860
 langgraph_api/cli.py,sha256=o_zD2vkky06dzW87HQgkIR1_h3ZCSZ8tgNvFCK9rKVo,19669
@@ -7,8 +7,8 @@ langgraph_api/config.py,sha256=eS0lIOMx-UhqEw9zDXcz3W5aOLX7laqxZUQcasuXoAs,12168
 langgraph_api/cron_scheduler.py,sha256=25wYzEQrhPEivZrAPYOmzLPDOQa-aFogU37mTXc9TJk,2566
 langgraph_api/errors.py,sha256=zlnl3xXIwVG0oGNKKpXf1an9Rn_SBDHSyhe53hU6aLw,1858
 langgraph_api/executor_entrypoint.py,sha256=CaX813ygtf9CpOaBkfkQXJAHjFtmlScCkrOvTDmu4Aw,750
-langgraph_api/feature_flags.py,sha256=x28NwFJXdfuGW2uUmon6lBSh0pGBo27bw_Se72TO4sM,409
-langgraph_api/graph.py,sha256=h1m6rsLiCocvMO283LLU03A5cBycxAIxixXu9mwzqsQ,25056
+langgraph_api/feature_flags.py,sha256=taZRhukeBV8r62EmEo92rxfBwYhIw56-P_UvSzQLzt8,576
+langgraph_api/graph.py,sha256=u10F9a8dxi7_Shx42xHOPi1Ri0occU6lUhWnTAF8_K4,25081
 langgraph_api/http.py,sha256=fyK-H-0UfNy_BzuVW3aWWGvhRavmGAVMkDwDArryJ_4,5659
 langgraph_api/http_metrics.py,sha256=MU9ccXt7aBb0AJ2SWEjwtbtbJEWmeqSdx7-CI51e32o,5594
 langgraph_api/logging.py,sha256=qB6q_cUba31edE4_D6dBGhdiUTpW7sXAOepUjYb_R50,5216
@@ -16,7 +16,7 @@ langgraph_api/metadata.py,sha256=0eGYhXOW6UIVDj2Y5mOdSJz_RadgJG8xmUsC9WqwsiE,834
 langgraph_api/patch.py,sha256=J0MmcfpZG15SUVaVcI0Z4x_c0-0rbbT7Pwh9fDAQOpA,1566
 langgraph_api/queue_entrypoint.py,sha256=k-Lz-HdaM2ICJacf9yCQw21GlJp00dPoHKuhe1PSrSs,6418
 langgraph_api/route.py,sha256=EBhELuJ1He-ZYcAnR5YTImcIeDtWthDae5CHELBxPkM,5056
-langgraph_api/schema.py,sha256=AsgF0dIjBvDd_PDy20mGqB_IkBLgVvSj8qRKG_lPlec,8440
+langgraph_api/schema.py,sha256=spZ_XPT4AMJfw2YatsdnMZZLzgB9Sm3YR8n0SlgGdJ8,8480
 langgraph_api/serde.py,sha256=Jkww6ixP5o2YZmnXtM7ihuAYC6YSuNDNPvE-8ILoqVo,5499
 langgraph_api/server.py,sha256=C9TO7N0mzyrLulT_2FtaJfgfFbm2B4yyYTdAGPxgIeE,7255
 langgraph_api/sse.py,sha256=SLdtZmTdh5D8fbWrQjuY9HYLd2dg8Rmi6ZMmFMVc2iE,4204
@@ -30,7 +30,7 @@ langgraph_api/webhook.py,sha256=SvSM1rdnNtiH4q3JQYmAqJUk2Sable5xAcwOLuRhtlo,1723
 langgraph_api/worker.py,sha256=FQRw3kL9ynDv_LNgY_OjjPZQBuAvSQpsW6nECnABvDg,15354
 langgraph_api/api/__init__.py,sha256=raFkYH50tsO-KjRmDbGVoHCuxuH58u1lrZbr-MlITIY,6262
 langgraph_api/api/a2a.py,sha256=HIHZkLnIcM1u1FJti-L2NH-h1I9BZ_d-QW9z3gFonn8,53995
-langgraph_api/api/assistants.py,sha256=OX83GCWwGR8MuEJKIzAPEC4LC3Aghs5vD3NGLNnijaU,17268
+langgraph_api/api/assistants.py,sha256=87FMcq8T4-7PfrAX1adOtBS_qQdomGOFpcFQw6PxZDA,17453
 langgraph_api/api/mcp.py,sha256=qe10ZRMN3f-Hli-9TI8nbQyWvMeBb72YB1PZVbyqBQw,14418
 langgraph_api/api/meta.py,sha256=Qyj6r5czkVJ81tpD6liFY7tlrmFDsiSfBr-4X8HJpRc,4834
 langgraph_api/api/openapi.py,sha256=If-z1ckXt-Yu5bwQytK1LWyX_T7G46UtLfixgEP8hwc,11959
@@ -46,6 +46,14 @@ langgraph_api/auth/studio_user.py,sha256=fojJpexdIZYI1w3awiqOLSwMUiK_M_3p4mlfQI0
 langgraph_api/auth/langsmith/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_api/auth/langsmith/backend.py,sha256=rdkz8IXLHusJqcoacvl2XuMZnQVR7PLpE0SHHcKTqv0,3664
 langgraph_api/auth/langsmith/client.py,sha256=Kn9503en1tmlNtkbvqRxYSRCOUrWaVpqvxyLLb1cgzY,3908
+langgraph_api/grpc_ops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langgraph_api/grpc_ops/client.py,sha256=VB740C9QMhJJrpAEjsADmasN-uGd0apGYtuv_ho0Rl8,2452
+langgraph_api/grpc_ops/ops.py,sha256=6xCWc5ylMcuTY_FFUJlnqPuRYOr0aOP96pXgx2X4I44,17139
+langgraph_api/grpc_ops/generated/__init__.py,sha256=dRiB_iGscPKdMpuLp9ueLwAmIfRaNjNXC64ABtb4cg8,135
+langgraph_api/grpc_ops/generated/core_api_pb2.py,sha256=5tvJCY00-ud-IO9OKIqRPEpUw12wjxYO3LQklMXB73o,42143
+langgraph_api/grpc_ops/generated/core_api_pb2.pyi,sha256=cpbtS6nf3aaOnbBbAsyCinttxiVELmje7xf0AaRcYUM,49208
+langgraph_api/grpc_ops/generated/core_api_pb2_grpc.py,sha256=fhlFCIrGpi3NPcyTcRsMQWXaw4Glr2-leMTyWiJer7M,52467
+langgraph_api/grpc_ops/scripts/generate_protos.sh,sha256=hSf1vgS0MoTlavbaUjiDKOSujuJ1RRN19UL6HS24JY4,1486
 langgraph_api/js/.gitignore,sha256=l5yI6G_V6F1600I1IjiUKn87f4uYIrBAYU1MOyBBhg4,59
 langgraph_api/js/.prettierrc,sha256=0es3ovvyNIqIw81rPQsdt1zCQcOdBqyR_DMbFE4Ifms,19
 langgraph_api/js/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -99,8 +107,8 @@ langgraph_runtime/store.py,sha256=7mowndlsIroGHv3NpTSOZDJR0lCuaYMBoTnTrewjslw,11
 LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
 logging.json,sha256=3RNjSADZmDq38eHePMm1CbP6qZ71AmpBtLwCmKU9Zgo,379
 openapi.json,sha256=21wu-NxdxyTQwZctNcEfRkLMnSBi0QhGAfwq5kg8XNU,172618
-langgraph_api-0.4.28.dist-info/METADATA,sha256=qTje00tzH8lBtQcOUOFLqvnoB8siS_uFb7bUVdNzzmk,3893
-langgraph_api-0.4.28.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langgraph_api-0.4.28.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
-langgraph_api-0.4.28.dist-info/licenses/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
-langgraph_api-0.4.28.dist-info/RECORD,,
+langgraph_api-0.4.29.dist-info/METADATA,sha256=VFgEuF3tQk5UU_jlddc4WCwXsgPp7A9STteH1LyMLzg,4012
+langgraph_api-0.4.29.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langgraph_api-0.4.29.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
+langgraph_api-0.4.29.dist-info/licenses/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
+langgraph_api-0.4.29.dist-info/RECORD,,