langgraph-api 0.2.77__tar.gz → 0.2.78__tar.gz

{langgraph_api-0.2.77 → langgraph_api-0.2.78}/Makefile

@@ -12,7 +12,7 @@ format:
 
 # test commands
 
-TEST ?= "tests/integration_tests/"
+TEST ?= tests/
 AUTH_TEST ?= "tests/integration_tests/test_custom_auth.py"
 LANGGRAPH_HTTP ?= {"disable_mcp": false}
 LANGGRAPH_AES_KEY ?= '1234567890123456'

{langgraph_api-0.2.77 → langgraph_api-0.2.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.2.77
+Version: 0.2.78
 Author-email: Nuno Campos <nuno@langchain.dev>, Will Fu-Hinthorn <will@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE

langgraph_api-0.2.78/langgraph_api/__init__.py

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

{langgraph_api-0.2.77 → langgraph_api-0.2.78}/langgraph_api/api/meta.py

@@ -1,8 +1,7 @@
-import os
-
 from starlette.responses import JSONResponse, PlainTextResponse
 
 from langgraph_api import __version__, config, metadata
+from langgraph_api.http_metrics import HTTP_METRICS_COLLECTOR
 from langgraph_api.route import ApiRequest
 from langgraph_license.validation import plus_features_enabled
 from langgraph_runtime.database import connect, pool_stats
@@ -26,6 +25,7 @@ async def meta_info(request: ApiRequest):
             "host": {
                 "kind": metadata.HOST,
                 "project_id": metadata.PROJECT_ID,
+                "host_revision_id": metadata.HOST_REVISION_ID,
                 "revision_id": metadata.REVISION,
                 "tenant_id": metadata.TENANT_ID,
             },
@@ -46,31 +46,31 @@ async def meta_metrics(request: ApiRequest):
     workers_active = worker_metrics["active"]
     workers_available = worker_metrics["available"]
 
+    http_metrics = HTTP_METRICS_COLLECTOR.get_metrics(
+        metadata.PROJECT_ID, metadata.HOST_REVISION_ID, metrics_format
+    )
+
     if metrics_format == "json":
         async with connect() as conn:
             resp = {
                 **pool_stats(),
                 "queue": await Runs.stats(conn),
+                **http_metrics,
             }
             if config.N_JOBS_PER_WORKER > 0:
                 resp["workers"] = worker_metrics
             return JSONResponse(resp)
     elif metrics_format == "prometheus":
-        # LANGSMITH_HOST_PROJECT_ID and LANGSMITH_HOST_REVISION_ID are injected
-        # into the deployed image by host-backend.
-        project_id = os.getenv("LANGSMITH_HOST_PROJECT_ID")
-        revision_id = os.getenv("LANGSMITH_HOST_REVISION_ID")
-
         async with connect() as conn:
             queue_stats = await Runs.stats(conn)
 
             metrics = [
                 "# HELP lg_api_num_pending_runs The number of runs currently pending.",
                 "# TYPE lg_api_num_pending_runs gauge",
-                f'lg_api_num_pending_runs{{project_id="{project_id}", revision_id="{revision_id}"}} {queue_stats["n_pending"]}',
+                f'lg_api_num_pending_runs{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {queue_stats["n_pending"]}',
                 "# HELP lg_api_num_running_runs The number of runs currently running.",
                 "# TYPE lg_api_num_running_runs gauge",
-                f'lg_api_num_running_runs{{project_id="{project_id}", revision_id="{revision_id}"}} {queue_stats["n_running"]}',
+                f'lg_api_num_running_runs{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {queue_stats["n_running"]}',
             ]
 
             if config.N_JOBS_PER_WORKER > 0:
@@ -78,15 +78,17 @@ async def meta_metrics(request: ApiRequest):
                     [
                         "# HELP lg_api_workers_max The maximum number of workers available.",
                         "# TYPE lg_api_workers_max gauge",
-                        f'lg_api_workers_max{{project_id="{project_id}", revision_id="{revision_id}"}} {workers_max}',
+                        f'lg_api_workers_max{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {workers_max}',
                         "# HELP lg_api_workers_active The number of currently active workers.",
                         "# TYPE lg_api_workers_active gauge",
-                        f'lg_api_workers_active{{project_id="{project_id}", revision_id="{revision_id}"}} {workers_active}',
+                        f'lg_api_workers_active{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {workers_active}',
                         "# HELP lg_api_workers_available The number of available (idle) workers.",
                         "# TYPE lg_api_workers_available gauge",
-                        f'lg_api_workers_available{{project_id="{project_id}", revision_id="{revision_id}"}} {workers_available}',
+                        f'lg_api_workers_available{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {workers_available}',
                     ]
                 )
 
+            metrics.extend(http_metrics)
+
         metrics_response = "\n".join(metrics)
         return PlainTextResponse(metrics_response)

{langgraph_api-0.2.77 → langgraph_api-0.2.78}/langgraph_api/api/openapi.py

@@ -80,6 +80,19 @@ def get_openapi_spec() -> str:
                 "API documentation will not show authentication requirements. "
                 "Add 'openapi' section to auth section of your `langgraph.json` file to specify security schemes."
             )
+
+    # Remove webhook parameters if webhooks are disabled
+    if HTTP_CONFIG and HTTP_CONFIG.get("disable_webhooks"):
+        webhook_schemas = ["CronCreate", "RunCreateStateful", "RunCreateStateless"]
+        for schema_name in webhook_schemas:
+            if schema_name in openapi["components"]["schemas"]:
+                schema = openapi["components"]["schemas"][schema_name]
+                if "properties" in schema and "webhook" in schema["properties"]:
+                    del schema["properties"]["webhook"]
+                    logger.info(
+                        f"Removed webhook parameter from {schema_name} schema due to disable_webhooks setting"
+                    )
+
     final = openapi
     if CUSTOM_OPENAPI_SPEC:
         final = merge_openapi_specs(openapi, CUSTOM_OPENAPI_SPEC)
@@ -100,11 +113,11 @@ def merge_openapi_specs(spec_a: dict, spec_b: dict) -> dict:
     Merge two OpenAPI specifications with spec_b taking precedence on conflicts.
 
     This function handles merging of the following keys:
-      - "openapi": Uses spec_b’s version.
+      - "openapi": Uses spec_b's version.
       - "info": Merges dictionaries with spec_b taking precedence.
       - "servers": Merges lists with deduplication (by URL and description).
       - "paths": For shared paths, merges HTTP methods:
-           - If a method exists in both, spec_b’s definition wins.
+           - If a method exists in both, spec_b's definition wins.
            - Otherwise, methods from both are preserved.
          Additionally, merges path-level "parameters" by (name, in).
       - "components": Merges per component type (schemas, responses, etc.).
@@ -217,7 +230,7 @@ def _merge_paths(paths_a: dict, paths_b: dict) -> dict:
 
     For each path:
       - If the path exists in both specs, merge HTTP methods:
-          - If a method exists in both, use spec_b’s definition.
+          - If a method exists in both, use spec_b's definition.
           - Otherwise, preserve both.
       - Additionally, merge path-level "parameters" if present.
 

{langgraph_api-0.2.77 → langgraph_api-0.2.78}/langgraph_api/config.py

@@ -37,6 +37,8 @@ class HttpConfig(TypedDict, total=False):
     """Disable /store routes"""
     disable_meta: bool
     """Disable /ok, /info, /metrics, and /docs routes"""
+    disable_webhooks: bool
+    """Disable webhooks calls on run completion in all routes"""
     cors: CorsConfig | None
     """CORS configuration"""
     disable_ui: bool

{langgraph_api-0.2.77 → langgraph_api-0.2.78}/langgraph_api/http.py

@@ -114,6 +114,11 @@ def get_loopback_client() -> JsonHttpClient:
 
 
 def is_retriable_error(exception: Exception) -> bool:
+    # httpx error hierarchy: https://www.python-httpx.org/exceptions/
+    # Retry all timeout related errors
+    if isinstance(exception, httpx.TimeoutException | httpx.NetworkError):
+        return True
+    # Seems to just apply to HttpStatusError but doesn't hurt to check all
     if isinstance(exception, httpx.HTTPError):
         return (
             getattr(exception, "response", None) is not None
@@ -143,6 +148,7 @@ async def http_request(
     connect_timeout: float | None = 5,
     request_timeout: float | None = 30,
     raise_error: bool = True,
+    client: JsonHttpClient | None = None,
 ) -> httpx.Response:
     """Make an HTTP request with retries.
 
@@ -163,7 +169,7 @@ async def http_request(
     if not path.startswith(("http://", "https://", "/")):
         raise ValueError("path must start with / or http")
 
-    client = get_http_client()
+    client = client or get_http_client()
 
     content = None
     if body is not None:

langgraph_api-0.2.78/langgraph_api/http_metrics.py

@@ -0,0 +1,166 @@
+from collections import defaultdict
+from typing import Any
+
+FILTERED_ROUTES = {"/ok", "/info", "/metrics", "/docs", "/openapi.json"}
+
+MAX_REQUEST_COUNT_ENTRIES = 5000
+MAX_HISTOGRAM_ENTRIES = 1000
+
+
+def get_route(route: Any) -> str | None:
+    try:
+        # default lg api routes use the custom APIRoute where scope["route"] is set to a string
+        if isinstance(route, str):
+            return route
+        else:
+            # custom FastAPI routes provided by user_router attach an object to scope["route"]
+            route_path = getattr(route, "path", None)
+            return route_path
+    except Exception:
+        return None
+
+
+def should_filter_route(route_path: str) -> bool:
+    # use endswith to honor MOUNT_PREFIX
+    return any(route_path.endswith(suffix) for suffix in FILTERED_ROUTES)
+
+
+class HTTPMetricsCollector:
+    def __init__(self):
+        # Counter: Key: (method, route, status), Value: count
+        self._request_counts: dict[tuple[str, str, int], int] = defaultdict(int)
+
+        self._histogram_buckets = [
+            0.01,
+            0.1,
+            0.5,
+            1,
+            5,
+            15,
+            30,
+            60,
+            120,
+            300,
+            600,
+            1800,
+            3600,
+            float("inf"),
+        ]
+        self._histogram_bucket_labels = [
+            "+Inf" if value == float("inf") else str(value)
+            for value in self._histogram_buckets
+        ]
+
+        self._histogram_data: dict[tuple[str, str], dict] = defaultdict(
+            lambda: {
+                "bucket_counts": [0] * len(self._histogram_buckets),
+                "sum": 0.0,
+                "count": 0,
+            }
+        )
+
+    def record_request(
+        self, method: str, route: Any, status: int, latency_ms: float
+    ) -> None:
+        route_path = get_route(route)
+        if route_path is None:
+            return
+
+        if should_filter_route(route_path):
+            return
+
+        request_count_key = (method, route_path, status)
+        histogram_key = (method, route_path)
+
+        if (
+            request_count_key not in self._request_counts
+            and len(self._request_counts) >= MAX_REQUEST_COUNT_ENTRIES
+        ):
+            return
+
+        if (
+            histogram_key not in self._histogram_data
+            and len(self._histogram_data) >= MAX_HISTOGRAM_ENTRIES
+        ):
+            return
+
+        self._request_counts[request_count_key] += 1
+
+        latency_seconds = latency_ms / 1000.0
+        hist_data = self._histogram_data[histogram_key]
+
+        for i, bucket_value in enumerate(self._histogram_buckets):
+            if latency_seconds <= bucket_value:
+                hist_data["bucket_counts"][i] += 1
+                break
+
+        hist_data["sum"] += latency_seconds
+        hist_data["count"] += 1
+
+    def get_metrics(
+        self, project_id: str, revision_id: str, format: str = "prometheus"
+    ) -> dict | list[str]:
+        if format == "json":
+            return {
+                "api": {
+                    "http_requests_total": [
+                        {
+                            "method": method,
+                            "path": path,
+                            "status": status,
+                            "count": count,
+                        }
+                        for (
+                            method,
+                            path,
+                            status,
+                        ), count in self._request_counts.items()
+                    ]
+                }
+            }
+
+        metrics = []
+
+        # Counter metrics
+        if self._request_counts:
+            metrics.extend(
+                [
+                    "# HELP lg_api_http_requests_total Total number of HTTP requests.",
+                    "# TYPE lg_api_http_requests_total counter",
+                ]
+            )
+
+            for (method, path, status), count in self._request_counts.items():
+                metrics.append(
+                    f'lg_api_http_requests_total{{project_id="{project_id}", revision_id="{revision_id}", method="{method}", path="{path}", status="{status}"}} {count}'
+                )
+
+        # Histogram metrics
+        if self._histogram_data:
+            metrics.extend(
+                [
+                    "# HELP lg_api_http_requests_latency_seconds HTTP request latency in seconds.",
+                    "# TYPE lg_api_http_requests_latency_seconds histogram",
+                ]
+            )
+
+            for (method, path), hist_data in self._histogram_data.items():
+                acc = 0
+                for i, bucket_count in enumerate(hist_data["bucket_counts"]):
+                    acc += bucket_count
+                    bucket_label = self._histogram_bucket_labels[i]
+                    metrics.append(
+                        f'lg_api_http_requests_latency_seconds_bucket{{project_id="{project_id}", revision_id="{revision_id}", method="{method}", path="{path}", le="{bucket_label}"}} {acc}'
+                    )
+
+                metrics.extend(
+                    [
+                        f'lg_api_http_requests_latency_seconds_sum{{project_id="{project_id}", revision_id="{revision_id}", method="{method}", path="{path}"}} {hist_data["sum"]:.6f}',
+                        f'lg_api_http_requests_latency_seconds_count{{project_id="{project_id}", revision_id="{revision_id}", method="{method}", path="{path}"}} {hist_data["count"]}',
+                    ]
+                )
+
+        return metrics
+
+
+HTTP_METRICS_COLLECTOR = HTTPMetricsCollector()

{langgraph_api-0.2.77 → langgraph_api-0.2.78}/langgraph_api/metadata.py

@@ -26,6 +26,7 @@ INTERVAL = 300
 REVISION = os.getenv("LANGSMITH_LANGGRAPH_API_REVISION")
 VARIANT = os.getenv("LANGSMITH_LANGGRAPH_API_VARIANT")
 PROJECT_ID = os.getenv("LANGSMITH_HOST_PROJECT_ID")
+HOST_REVISION_ID = os.getenv("LANGSMITH_HOST_REVISION_ID")
 TENANT_ID = os.getenv("LANGSMITH_TENANT_ID")
 if PROJECT_ID:
     try:

{langgraph_api-0.2.77 → langgraph_api-0.2.78}/langgraph_api/middleware/http_logger.py

@@ -5,6 +5,8 @@ import structlog
 from starlette.requests import ClientDisconnect
 from starlette.types import Message, Receive, Scope, Send
 
+from langgraph_api.http_metrics import HTTP_METRICS_COLLECTOR
+
 asgi = structlog.stdlib.get_logger("asgi")
 
 PATHS_IGNORE = {"/ok", "/metrics"}
@@ -64,13 +66,22 @@ class AccessLoggerMiddleware:
         finally:
             info["end_time"] = loop.time()
             latency = int((info["end_time"] - info["start_time"]) * 1_000)
+
+            status = info["response"].get("status")
+            method = scope.get("method")
+            path = scope.get("path")
+            route = scope.get("route")
+
+            if method and route and status:
+                HTTP_METRICS_COLLECTOR.record_request(method, route, status, latency)
+
             self.logger.info(
-                f"{scope.get('method')} {scope.get('path')} {info['response'].get('status')} {latency}ms",
-                method=scope.get("method"),
-                path=scope.get("path"),
-                status=info["response"].get("status"),
+                f"{method} {path} {status} {latency}ms",
+                method=method,
+                path=path,
+                status=status,
                 latency_ms=latency,
-                route=scope.get("route"),
+                route=route,
                 path_params=scope.get("path_params"),
                 query_string=scope.get("query_string").decode(),
                 proto=scope.get("http_version"),

{langgraph_api-0.2.77 → langgraph_api-0.2.78}/langgraph_api/webhook.py

@@ -2,13 +2,20 @@ from datetime import UTC, datetime
 
 import structlog
 
-from langgraph_api.http import get_http_client, get_loopback_client
+from langgraph_api.config import HTTP_CONFIG
+from langgraph_api.http import get_http_client, get_loopback_client, http_request
 from langgraph_api.worker import WorkerResult
 
 logger = structlog.stdlib.get_logger(__name__)
 
 
 async def call_webhook(result: "WorkerResult") -> None:
+    if HTTP_CONFIG and HTTP_CONFIG.get("disable_webhooks"):
+        logger.info(
+            "Webhooks disabled, skipping webhook call", webhook=result["webhook"]
+        )
+        return
+
     checkpoint = result["checkpoint"]
     payload = {
         **result["run"],
@@ -28,7 +35,7 @@ async def call_webhook(result: "WorkerResult") -> None:
             webhook_client = get_loopback_client()
         else:
             webhook_client = get_http_client()
-        await webhook_client.post(webhook, json=payload, total_timeout=20)
+        await http_request("POST", webhook, json=payload, client=webhook_client)
         await logger.ainfo(
             "Background worker called webhook",
             webhook=result["webhook"],

langgraph_api-0.2.77/langgraph_api/__init__.py

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