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

langgraph_api/queue_entrypoint.py

@@ -18,7 +18,6 @@ import logging.config
 import pathlib
 import signal
 from contextlib import asynccontextmanager
-from typing import cast
 
 import structlog
 
@@ -50,7 +49,7 @@ async def health_and_metrics_server():
             metrics_format = "prometheus"
 
         metrics = get_metrics()
-        worker_metrics = cast(dict[str, int], metrics["workers"])
+        worker_metrics = metrics["workers"]
         workers_max = worker_metrics["max"]
         workers_active = worker_metrics["active"]
         workers_available = worker_metrics["available"]

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/self_hosted_metrics.py

@@ -0,0 +1,380 @@
+import os
+
+import structlog
+from opentelemetry import metrics
+from opentelemetry.exporter.otlp.proto.http.metric_exporter import (
+    OTLPMetricExporter,
+)
+from opentelemetry.metrics import CallbackOptions, Observation
+from opentelemetry.sdk.metrics import MeterProvider
+from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
+from opentelemetry.sdk.resources import Resource
+
+from langgraph_api import asyncio as lg_asyncio
+from langgraph_api import config, metadata
+from langgraph_api.http_metrics_utils import HTTP_LATENCY_BUCKETS
+from langgraph_runtime.database import connect, pool_stats
+from langgraph_runtime.metrics import get_metrics
+from langgraph_runtime.ops import Runs
+
+logger = structlog.stdlib.get_logger(__name__)
+
+_meter_provider = None
+_customer_attributes = {}
+
+_http_request_counter = None
+_http_latency_histogram = None
+
+
+def initialize_self_hosted_metrics():
+    global \
+        _meter_provider, \
+        _http_request_counter, \
+        _http_latency_histogram, \
+        _customer_attributes
+
+    if not config.SELF_HOSTED_METRICS_ENABLED:
+        return
+
+    if not config.SELF_HOSTED_METRICS_ENDPOINT:
+        raise RuntimeError(
+            "SELF_HOSTED_METRICS_ENABLED is true but no SELF_HOSTED_METRICS_ENDPOINT is configured"
+        )
+
+    # for now, this is only enabled for fully self-hosted customers
+    # we will need to update the otel collector auth model to support hybrid customers
+    if not config.LANGGRAPH_CLOUD_LICENSE_KEY:
+        logger.warning(
+            "Self-hosted metrics require a license key, and do not work with hybrid deployments yet."
+        )
+        return
+
+    try:
+        exporter = OTLPMetricExporter(
+            endpoint=config.SELF_HOSTED_METRICS_ENDPOINT,
+            headers={"X-Langchain-License-Key": config.LANGGRAPH_CLOUD_LICENSE_KEY},
+        )
+
+        # this will periodically export metrics to our beacon lgp otel collector in a separate thread
+        metric_reader = PeriodicExportingMetricReader(
+            exporter=exporter,
+            export_interval_millis=config.SELF_HOSTED_METRICS_EXPORT_INTERVAL_MS,
+        )
+
+        resource_attributes = {
+            "service.name": "LGP_Self_Hosted",
+        }
+
+        resource = Resource.create(resource_attributes)
+
+        if config.LANGGRAPH_CLOUD_LICENSE_KEY:
+            try:
+                from langgraph_license.validation import (
+                    CUSTOMER_ID,  # type: ignore[unresolved-import]
+                    CUSTOMER_NAME,  # type: ignore[unresolved-import]
+                )
+
+                if CUSTOMER_ID:
+                    _customer_attributes["customer_id"] = CUSTOMER_ID
+                if CUSTOMER_NAME:
+                    _customer_attributes["customer_name"] = CUSTOMER_NAME
+            except ImportError:
+                pass
+            except Exception as e:
+                logger.warning("Failed to get customer info from license", exc_info=e)
+
+        # resolves to pod name in k8s, or container id in docker
+        instance_id = os.environ.get("HOSTNAME")
+        if instance_id:
+            _customer_attributes["instance_id"] = instance_id
+
+        _meter_provider = MeterProvider(
+            metric_readers=[metric_reader], resource=resource
+        )
+        metrics.set_meter_provider(_meter_provider)
+
+        meter = metrics.get_meter("langgraph_api.self_hosted")
+
+        meter.create_observable_gauge(
+            name="lg_api_num_pending_runs",
+            description="The number of runs currently pending",
+            unit="1",
+            callbacks=[_get_pending_runs_callback],
+        )
+
+        meter.create_observable_gauge(
+            name="lg_api_num_running_runs",
+            description="The number of runs currently running",
+            unit="1",
+            callbacks=[_get_running_runs_callback],
+        )
+
+        if config.N_JOBS_PER_WORKER > 0:
+            meter.create_observable_gauge(
+                name="lg_api_workers_max",
+                description="The maximum number of workers available",
+                unit="1",
+                callbacks=[_get_workers_max_callback],
+            )
+
+            meter.create_observable_gauge(
+                name="lg_api_workers_active",
+                description="The number of currently active workers",
+                unit="1",
+                callbacks=[_get_workers_active_callback],
+            )
+
+            meter.create_observable_gauge(
+                name="lg_api_workers_available",
+                description="The number of available (idle) workers",
+                unit="1",
+                callbacks=[_get_workers_available_callback],
+            )
+
+        if not config.IS_QUEUE_ENTRYPOINT and not config.IS_EXECUTOR_ENTRYPOINT:
+            _http_request_counter = meter.create_counter(
+                name="lg_api_http_requests_total",
+                description="Total number of HTTP requests",
+                unit="1",
+            )
+
+            _http_latency_histogram = meter.create_histogram(
+                name="lg_api_http_requests_latency_seconds",
+                description="HTTP request latency in seconds",
+                unit="s",
+                explicit_bucket_boundaries_advisory=[
+                    b for b in HTTP_LATENCY_BUCKETS if b != float("inf")
+                ],
+            )
+
+        meter.create_observable_gauge(
+            name="lg_api_pg_pool_max",
+            description="The maximum size of the postgres connection pool",
+            unit="1",
+            callbacks=[_get_pg_pool_max_callback],
+        )
+
+        meter.create_observable_gauge(
+            name="lg_api_pg_pool_size",
+            description="Number of connections currently managed by the postgres connection pool",
+            unit="1",
+            callbacks=[_get_pg_pool_size_callback],
+        )
+
+        meter.create_observable_gauge(
+            name="lg_api_pg_pool_available",
+            description="Number of connections currently idle in the postgres connection pool",
+            unit="1",
+            callbacks=[_get_pg_pool_available_callback],
+        )
+
+        meter.create_observable_gauge(
+            name="lg_api_redis_pool_max",
+            description="The maximum size of the redis connection pool",
+            unit="1",
+            callbacks=[_get_redis_pool_max_callback],
+        )
+
+        meter.create_observable_gauge(
+            name="lg_api_redis_pool_size",
+            description="Number of connections currently in use in the redis connection pool",
+            unit="1",
+            callbacks=[_get_redis_pool_size_callback],
+        )
+
+        meter.create_observable_gauge(
+            name="lg_api_redis_pool_available",
+            description="Number of connections currently idle in the redis connection pool",
+            unit="1",
+            callbacks=[_get_redis_pool_available_callback],
+        )
+
+        logger.info(
+            "Self-hosted metrics initialized successfully",
+            endpoint=config.SELF_HOSTED_METRICS_ENDPOINT,
+            export_interval_ms=config.SELF_HOSTED_METRICS_EXPORT_INTERVAL_MS,
+        )
+
+    except Exception as e:
+        logger.exception("Failed to initialize self-hosted metrics", exc_info=e)
+
+
+def shutdown_self_hosted_metrics():
+    global _meter_provider
+
+    if _meter_provider:
+        try:
+            logger.info("Shutting down self-hosted metrics")
+            _meter_provider.shutdown(timeout_millis=5000)
+            _meter_provider = None
+        except Exception as e:
+            logger.exception("Failed to shutdown self-hosted metrics", exc_info=e)
+
+
+def record_http_request(
+    method: str, route_path: str, status: int, latency_seconds: float
+):
+    if not _meter_provider or not _http_request_counter or not _http_latency_histogram:
+        return
+
+    attributes = {"method": method, "path": route_path, "status": str(status)}
+    if _customer_attributes:
+        attributes.update(_customer_attributes)
+
+    _http_request_counter.add(1, attributes)
+    _http_latency_histogram.record(latency_seconds, attributes)
+
+
+def _get_queue_stats():
+    async def _fetch_queue_stats():
+        try:
+            async with connect() as conn:
+                return await Runs.stats(conn)
+        except Exception as e:
+            logger.warning("Failed to get queue stats from database", exc_info=e)
+            return {"n_pending": 0, "n_running": 0}
+
+    try:
+        future = lg_asyncio.run_coroutine_threadsafe(_fetch_queue_stats())
+        return future.result(timeout=5)
+    except Exception as e:
+        logger.warning("Failed to get queue stats", exc_info=e)
+        return {"n_pending": 0, "n_running": 0}
+
+
+def _get_pool_stats():
+    # _get_pool() inside the pool_stats fn will not work correctly if called from the daemon thread created by PeriodicExportingMetricReader,
+    # so we submit this as a coro to run in the main event loop
+    async def _fetch_pool_stats():
+        try:
+            return pool_stats(
+                metadata.PROJECT_ID, metadata.HOST_REVISION_ID, format="json"
+            )
+        except Exception as e:
+            logger.warning("Failed to get pool stats", exc_info=e)
+            return {"postgres": {}, "redis": {}}
+
+    try:
+        future = lg_asyncio.run_coroutine_threadsafe(_fetch_pool_stats())
+        return future.result(timeout=5)
+    except Exception as e:
+        logger.warning("Failed to get pool stats", exc_info=e)
+        return {"postgres": {}, "redis": {}}
+
+
+def _get_pending_runs_callback(options: CallbackOptions):
+    try:
+        stats = _get_queue_stats()
+        return [Observation(stats.get("n_pending", 0), attributes=_customer_attributes)]
+    except Exception as e:
+        logger.warning("Failed to get pending runs", exc_info=e)
+        return [Observation(0, attributes=_customer_attributes)]
+
+
+def _get_running_runs_callback(options: CallbackOptions):
+    try:
+        stats = _get_queue_stats()
+        return [Observation(stats.get("n_running", 0), attributes=_customer_attributes)]
+    except Exception as e:
+        logger.warning("Failed to get running runs", exc_info=e)
+        return [Observation(0, attributes=_customer_attributes)]
+
+
+def _get_workers_max_callback(options: CallbackOptions):
+    try:
+        metrics_data = get_metrics()
+        worker_metrics = metrics_data.get("workers", {})
+        return [
+            Observation(worker_metrics.get("max", 0), attributes=_customer_attributes)
+        ]
+    except Exception as e:
+        logger.warning("Failed to get max workers", exc_info=e)
+        return [Observation(0, attributes=_customer_attributes)]
+
+
+def _get_workers_active_callback(options: CallbackOptions):
+    try:
+        metrics_data = get_metrics()
+        worker_metrics = metrics_data.get("workers", {})
+        return [
+            Observation(
+                worker_metrics.get("active", 0), attributes=_customer_attributes
+            )
+        ]
+    except Exception as e:
+        logger.warning("Failed to get active workers", exc_info=e)
+        return [Observation(0, attributes=_customer_attributes)]
+
+
+def _get_workers_available_callback(options: CallbackOptions):
+    try:
+        metrics_data = get_metrics()
+        worker_metrics = metrics_data.get("workers", {})
+        return [
+            Observation(
+                worker_metrics.get("available", 0), attributes=_customer_attributes
+            )
+        ]
+    except Exception as e:
+        logger.warning("Failed to get available workers", exc_info=e)
+        return [Observation(0, attributes=_customer_attributes)]
+
+
+def _get_pg_pool_max_callback(options: CallbackOptions):
+    try:
+        stats = _get_pool_stats()
+        pg_max = stats.get("postgres", {}).get("pool_max", 0)
+        return [Observation(pg_max, attributes=_customer_attributes)]
+    except Exception as e:
+        logger.warning("Failed to get PG pool max", exc_info=e)
+        return [Observation(0, attributes=_customer_attributes)]
+
+
+def _get_pg_pool_size_callback(options: CallbackOptions):
+    try:
+        stats = _get_pool_stats()
+        pg_size = stats.get("postgres", {}).get("pool_size", 0)
+        return [Observation(pg_size, attributes=_customer_attributes)]
+    except Exception as e:
+        logger.warning("Failed to get PG pool size", exc_info=e)
+        return [Observation(0, attributes=_customer_attributes)]
+
+
+def _get_pg_pool_available_callback(options: CallbackOptions):
+    try:
+        stats = _get_pool_stats()
+        pg_available = stats.get("postgres", {}).get("pool_available", 0)
+        return [Observation(pg_available, attributes=_customer_attributes)]
+    except Exception as e:
+        logger.warning("Failed to get PG pool available", exc_info=e)
+        return [Observation(0, attributes=_customer_attributes)]
+
+
+def _get_redis_pool_max_callback(options: CallbackOptions):
+    try:
+        stats = _get_pool_stats()
+        redis_max = stats.get("redis", {}).get("max_connections", 0)
+        return [Observation(redis_max, attributes=_customer_attributes)]
+    except Exception as e:
+        logger.warning("Failed to get Redis pool max", exc_info=e)
+        return [Observation(0, attributes=_customer_attributes)]
+
+
+def _get_redis_pool_size_callback(options: CallbackOptions):
+    try:
+        stats = _get_pool_stats()
+        redis_size = stats.get("redis", {}).get("in_use_connections", 0)
+        return [Observation(redis_size, attributes=_customer_attributes)]
+    except Exception as e:
+        logger.warning("Failed to get Redis pool size", exc_info=e)
+        return [Observation(0, attributes=_customer_attributes)]
+
+
+def _get_redis_pool_available_callback(options: CallbackOptions):
+    try:
+        stats = _get_pool_stats()
+        redis_available = stats.get("redis", {}).get("idle_connections", 0)
+        return [Observation(redis_available, attributes=_customer_attributes)]
+    except Exception as e:
+        logger.warning("Failed to get Redis pool available", exc_info=e)
+        return [Observation(0, attributes=_customer_attributes)]

langgraph_api/stream.py

@@ -231,6 +231,8 @@ async def astream_state(
 
     # stream run
     if use_astream_events:
+        if USE_RUNTIME_CONTEXT_API:
+            kwargs["context"] = context
         async with (
             stack,
             aclosing(  # type: ignore[invalid-argument-type]

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

@@ -1,12 +1,14 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.4.28
+Version: 0.4.30
 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
@@ -15,7 +17,11 @@ Requires-Dist: langgraph-runtime-inmem<0.15.0,>=0.14.0
 Requires-Dist: langgraph-sdk>=0.2.0
 Requires-Dist: langgraph>=0.4.0
 Requires-Dist: langsmith>=0.3.45
+Requires-Dist: opentelemetry-api>=1.37.0
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.37.0
+Requires-Dist: opentelemetry-sdk>=1.37.0
 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.30.dist-info}/RECORD

@@ -1,28 +1,30 @@
-langgraph_api/__init__.py,sha256=QZ0p7EqvqxpClz_YH3XtlxgPmyXKcK-CGg_B_p5Z7w0,23
+langgraph_api/__init__.py,sha256=oJL8XtG8mmnvRfpE8L0X7P-SyENhGR162XgumWN6O4A,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
 langgraph_api/command.py,sha256=Bh-rvuTLwdHCqFWryCjB1M8oWxPBwRBUjMNj_04KPxM,852
-langgraph_api/config.py,sha256=eS0lIOMx-UhqEw9zDXcz3W5aOLX7laqxZUQcasuXoAs,12168
+langgraph_api/config.py,sha256=AMcVZn8_uWjyfFEnYw6o8S7HQhwcWpAgkGu7m-gpdsY,12481
 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/http_metrics.py,sha256=iOJKQW8VdgkhWp5aBjy1RUghH5noxJTVFPEmmXwgCbE,5097
+langgraph_api/http_metrics_utils.py,sha256=sjxF7SYGTzY0Wz_G0dzatsYNnWr31S6ujej4JmBG2yo,866
 langgraph_api/logging.py,sha256=qB6q_cUba31edE4_D6dBGhdiUTpW7sXAOepUjYb_R50,5216
 langgraph_api/metadata.py,sha256=0eGYhXOW6UIVDj2Y5mOdSJz_RadgJG8xmUsC9WqwsiE,8342
 langgraph_api/patch.py,sha256=J0MmcfpZG15SUVaVcI0Z4x_c0-0rbbT7Pwh9fDAQOpA,1566
-langgraph_api/queue_entrypoint.py,sha256=k-Lz-HdaM2ICJacf9yCQw21GlJp00dPoHKuhe1PSrSs,6418
+langgraph_api/queue_entrypoint.py,sha256=zK2V03xHsy7Y9wq_nHuCBc3_GnCuKJNR24BGv8pREnY,6372
 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/self_hosted_metrics.py,sha256=JyDGs7lTKndL_vdtGq4rbPtOGdxCkil9_u6d_wTJeds,13980
 langgraph_api/serde.py,sha256=Jkww6ixP5o2YZmnXtM7ihuAYC6YSuNDNPvE-8ILoqVo,5499
 langgraph_api/server.py,sha256=C9TO7N0mzyrLulT_2FtaJfgfFbm2B4yyYTdAGPxgIeE,7255
 langgraph_api/sse.py,sha256=SLdtZmTdh5D8fbWrQjuY9HYLd2dg8Rmi6ZMmFMVc2iE,4204
 langgraph_api/state.py,sha256=AjkLbUQakIwK7oGzJ8oqubazRsXxG3vDMnRa0s0mzDM,4716
 langgraph_api/store.py,sha256=NIoNZojs6NbtG3VLBPQEFNttvp7XPkHAfjbQ3gY7aLY,4701
-langgraph_api/stream.py,sha256=Dqkj0soBYaZxHpI46OZAqQA4OxpLE1yUxQsHjXSR-Fk,21091
+langgraph_api/stream.py,sha256=VA1CvR3kN6d03KAkSJgTVum4zfkI42cEGRqoGeEufeI,21167
 langgraph_api/thread_ttl.py,sha256=KyHnvD0e1p1cV4Z_ZvKNVzDztuI2RBCUsUO2V7GlOSw,1951
 langgraph_api/traceblock.py,sha256=Qq5CUdefnMDaRDnyvBSWGBClEj-f3oO7NbH6fedxOSE,630
 langgraph_api/validation.py,sha256=86jftgOsMa7tkeshBw6imYe7zyUXPoVuf5Voh6dFiR8,5285
@@ -30,9 +32,9 @@ 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/meta.py,sha256=464nRdZPCPG-T1rouypReI8SPLHZlEec8dIj22H1Vvo,4787
 langgraph_api/api/openapi.py,sha256=If-z1ckXt-Yu5bwQytK1LWyX_T7G46UtLfixgEP8hwc,11959
 langgraph_api/api/runs.py,sha256=keHlFu1iy-l1IICJHc6AKrSUoQA-LZi6FYsja7la9Xw,25436
 langgraph_api/api/store.py,sha256=xGcPFx4v-VxlK6HRU9uCjzCQ0v66cvc3o_PB5_g7n0Q,5550
@@ -46,6 +48,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=Qav2DuCMUSmR8nP4-fVtUBbY0Vc42jqjCs3L4LdIl-0,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 +109,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.30.dist-info/METADATA,sha256=PYv7Rf2AYRdZAi98AFcUtg3w2E0rti6CIhFXkSBroT4,4156
+langgraph_api-0.4.30.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langgraph_api-0.4.30.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
+langgraph_api-0.4.30.dist-info/licenses/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
+langgraph_api-0.4.30.dist-info/RECORD,,