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

{langgraph_api-0.2.77 → langgraph_api-0.2.83}/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.83}/PKG-INFO

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

{langgraph_api-0.2.77 → langgraph_api-0.2.83}/benchmark/README.md

@@ -6,7 +6,14 @@ K6 is a modern load testing tool that allows you to test the performance and rel
 
 ### Available Tests
 
-1. Burst - Kick off a burst of /run/wait requests.
+We use a local benchmark agent that has a MODE that can be any of the following:
+- `single` - Run a single node
+- `parallel` - Run EXPAND nodes in parallel
+- `sequential` - Run EXPAND nodes in sequence
+
+By default, MODE is `single` and EXPAND is 50.
+
+1. Burst - Kick off a burst of /run/wait requests. Default BURST_SIZE is 100.
 
 ## Running Tests Locally
 
@@ -19,12 +26,15 @@ K6 is a modern load testing tool that allows you to test the performance and rel
 ### Basic Usage
 
 ```bash
-# Run burst test with default burst size (50)
+# Run burst test with default burst size
 make benchmark-burst
 
 # Run burst test with custom burst size
 BURST_SIZE=500 make benchmark-burst
 
+# Run burst test with a different mode and expand size
+MODE='parallel' EXPAND=100 make benchmark-burst
+
 # Run burst test against a deployment
 BASE_URL=https://jdr-debug-31ac2c83eef557309f21c1e98d822025.us.langgraph.app make benchmark-burst
 

{langgraph_api-0.2.77 → langgraph_api-0.2.83}/benchmark/burst.js

@@ -15,7 +15,9 @@ const burstSuccessRate = new Rate('burst_success_rate');
 
 // URL of your LangGraph server
 const BASE_URL = __ENV.BASE_URL || 'http://localhost:9123';
-const BURST_SIZE = parseInt(__ENV.BURST_SIZE || '50');
+const BURST_SIZE = parseInt(__ENV.BURST_SIZE || '100');
+const MODE = __ENV.MODE || 'single';
+const EXPAND = parseInt(__ENV.EXPAND || '50');
 
 // Burst testing configuration
 export let options = {
@@ -28,7 +30,7 @@ export let options = {
     },
   },
   thresholds: {
-    'run_duration': ['p(95)<3500'],
+    'run_duration': ['p(95)<2000'],
     'burst_success_rate': ['rate>0.99'],
   },
 };
@@ -50,8 +52,10 @@ export default function() {
     // Create a payload with the LangGraph agent configuration
     const payload = JSON.stringify({
       assistant_id: "benchmark",
-      config: { delay: 0.1 },
-      input: {delay: 0.1, random_value: 'hello'},
+      input: {mode: MODE, expand: EXPAND},
+      config: {
+        recursion_limit: EXPAND + 2,
+      }
     });
 
     // Make a single request to the wait endpoint
@@ -60,15 +64,18 @@ export default function() {
       timeout: '35s'
     });
 
+    // Don't include verification in the duration of the request
+    const duration = new Date().getTime() - startTime;
+
     // Check the response
+    const expected_length = MODE === 'single' ? 1 : EXPAND + 1;
     const success = check(response, {
       'Run completed successfully': (r) => r.status === 200,
-      'Response contains data': (r) => r.body.length > 0,
+      'Response contains expected number of messages': (r) => JSON.parse(r.body).messages.length === expected_length,
     });
 
     if (success) {
       // Record success metrics
-      const duration = new Date().getTime() - startTime;
       runDuration.add(duration);
       successfulRuns.add(1);
       burstSuccessRate.add(1);  // 1 = success

langgraph_api-0.2.83/langgraph_api/__init__.py

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

{langgraph_api-0.2.77 → langgraph_api-0.2.83}/langgraph_api/api/__init__.py

@@ -1,4 +1,5 @@
 import asyncio
+import functools
 import importlib
 import importlib.util
 import os
@@ -27,7 +28,11 @@ from langgraph_runtime.database import connect, healthcheck
 logger = structlog.stdlib.get_logger(__name__)
 
 
-async def ok(request: Request):
+async def ok(request: Request, *, disabled: bool = False):
+    if disabled:
+        # We still expose an /ok endpoint even if disable_meta is set so that
+        # the operator knows the server started up.
+        return JSONResponse({"ok": True})
     check_db = int(request.query_params.get("check_db", "0"))  # must be "0" or "1"
     if check_db:
         await healthcheck()
@@ -126,6 +131,13 @@ if HTTP_CONFIG:
         user_router = load_custom_app(router_import)
     if not HTTP_CONFIG.get("disable_meta"):
         routes.extend(meta_routes)
+    else:
+        # Otherwise the deployment will never be considered healthy
+        routes.append(
+            Route(
+                "/ok", functools.partial(ok, disabled=True), methods=["GET"], name="ok"
+            )
+        )
     if protected_routes:
         routes.append(
             Mount(

{langgraph_api-0.2.77 → langgraph_api-0.2.83}/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.83}/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.83}/langgraph_api/cli.py

@@ -346,7 +346,7 @@ def run_server(
 - 📚 API Docs: \033[36m{local_url}/docs\033[0m
 
 This in-memory server is designed for development and testing.
-For production use, please use LangGraph Cloud.
+For production use, please use LangGraph Platform.
 
 """
         logger.info(welcome)

{langgraph_api-0.2.77 → langgraph_api-0.2.83}/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
@@ -153,7 +155,7 @@ POSTGRES_POOL_MAX_SIZE = env("LANGGRAPH_POSTGRES_POOL_MAX_SIZE", cast=int, defau
 RESUMABLE_STREAM_TTL_SECONDS = env(
     "RESUMABLE_STREAM_TTL_SECONDS",
     cast=int,
-    default=3600,  # 1 hour
+    default=120,  # 2 minutes
 )
 
 

{langgraph_api-0.2.77 → langgraph_api-0.2.83}/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.83/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.83}/langgraph_api/js/remote.py

@@ -1,6 +1,8 @@
 import asyncio
+import json
 import logging
 import os
+import re
 import shutil
 import ssl
 from collections import deque
@@ -452,6 +454,26 @@ async def run_js_http_process(paths_str: str, http_config: dict, watch: bool = F
                 attempt += 1
 
 
+_BAD_SURROGATE_RE = re.compile(r"\\u[dD][89a-fA-F][0-9a-fA-F]{2}")
+_BAD_ESCAPE_RE = re.compile(r"\\(?![\"\\/bfnrtu])")
+
+
+def _safe_json_loads(data: bytes):
+    """Attempt *orjson.loads* first; if it fails, repair common escape issues.
+
+    For a time, we had a bug in our surrogate cleanup in serde.py, which
+    allowed sequences containing a stray backslash to be stored which would
+    then fail upon loading. This function attempts to repair those sequences.
+    """
+    try:
+        return orjson.loads(data)
+    except orjson.JSONDecodeError:
+        txt = data.decode("utf-8", "replace")
+        txt = _BAD_ESCAPE_RE.sub(r"\\\\", txt)
+        txt = _BAD_SURROGATE_RE.sub("", txt)
+        return json.loads(txt)
+
+
 class PassthroughSerialiser(SerializerProtocol):
     def dumps(self, obj: Any) -> bytes:
         return json_dumpb(obj)
@@ -460,13 +482,13 @@ class PassthroughSerialiser(SerializerProtocol):
         return "json", json_dumpb(obj)
 
     def loads(self, data: bytes) -> Any:
-        return orjson.loads(data)
+        return _safe_json_loads(data)
 
     def loads_typed(self, data: tuple[str, bytes]) -> Any:
         type, payload = data
         if type != "json":
             raise ValueError(f"Unsupported type {type}")
-        return orjson.loads(payload)
+        return _safe_json_loads(payload)
 
 
 def _get_passthrough_checkpointer():

{langgraph_api-0.2.77 → langgraph_api-0.2.83}/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:
@@ -54,13 +55,15 @@ RUN_COUNTER = 0
 NODE_COUNTER = 0
 FROM_TIMESTAMP = datetime.now(UTC).isoformat()
 
-if (
-    "api.smith.langchain.com" in LANGSMITH_AUTH_ENDPOINT
-    and not LANGGRAPH_CLOUD_LICENSE_KEY
-):
-    METADATA_ENDPOINT = LANGSMITH_AUTH_ENDPOINT.rstrip("/") + "/v1/metadata/submit"
-else:
-    METADATA_ENDPOINT = "https://api.smith.langchain.com/v1/metadata/submit"
+# Beacon endpoint for license key submissions
+BEACON_ENDPOINT = "https://api.smith.langchain.com/v1/metadata/submit"
+
+# LangChain auth endpoint for API key submissions
+LANGCHAIN_METADATA_ENDPOINT = None
+if LANGSMITH_AUTH_ENDPOINT:
+    LANGCHAIN_METADATA_ENDPOINT = (
+        LANGSMITH_AUTH_ENDPOINT.rstrip("/") + "/v1/metadata/submit"
+    )
 
 
 def incr_runs(*, incr: int = 1) -> None:
@@ -81,8 +84,10 @@ async def metadata_loop() -> None:
     if not LANGGRAPH_CLOUD_LICENSE_KEY and not LANGSMITH_API_KEY:
         return
 
-    if LANGGRAPH_CLOUD_LICENSE_KEY and not LANGGRAPH_CLOUD_LICENSE_KEY.startswith(
-        "lcl_"
+    if (
+        LANGGRAPH_CLOUD_LICENSE_KEY
+        and not LANGGRAPH_CLOUD_LICENSE_KEY.startswith("lcl_")
+        and not LANGSMITH_API_KEY
     ):
         logger.info("Running in air-gapped mode, skipping metadata loop")
         return
@@ -101,9 +106,7 @@ async def metadata_loop() -> None:
         NODE_COUNTER = 0
         FROM_TIMESTAMP = to_timestamp
 
-        payload = {
-            "license_key": LANGGRAPH_CLOUD_LICENSE_KEY,
-            "api_key": LANGSMITH_API_KEY,
+        base_payload = {
             "from_timestamp": from_timestamp,
             "to_timestamp": to_timestamp,
             "tags": {
@@ -129,17 +132,66 @@ async def metadata_loop() -> None:
             },
             "logs": [],
         }
-        try:
-            await http_request(
-                "POST",
-                METADATA_ENDPOINT,
-                body=orjson.dumps(payload),
-                headers={"Content-Type": "application/json"},
-            )
-        except Exception as e:
+
+        # Track successful submissions
+        submissions_attempted = []
+        submissions_failed = []
+
+        # 1. Send to beacon endpoint if license key starts with lcl_
+        if LANGGRAPH_CLOUD_LICENSE_KEY and LANGGRAPH_CLOUD_LICENSE_KEY.startswith(
+            "lcl_"
+        ):
+            beacon_payload = {
+                **base_payload,
+                "license_key": LANGGRAPH_CLOUD_LICENSE_KEY,
+            }
+            submissions_attempted.append("beacon")
+            try:
+                await http_request(
+                    "POST",
+                    BEACON_ENDPOINT,
+                    body=orjson.dumps(beacon_payload),
+                    headers={"Content-Type": "application/json"},
+                )
+                await logger.ainfo("Successfully submitted metadata to beacon endpoint")
+            except Exception as e:
+                submissions_failed.append("beacon")
+                await logger.awarning(
+                    "Beacon metadata submission failed.", error=str(e)
+                )
+
+        # 2. Send to langchain auth endpoint if API key is set
+        if LANGSMITH_API_KEY and LANGCHAIN_METADATA_ENDPOINT:
+            langchain_payload = {
+                **base_payload,
+                "api_key": LANGSMITH_API_KEY,
+            }
+            submissions_attempted.append("langchain")
+            try:
+                await http_request(
+                    "POST",
+                    LANGCHAIN_METADATA_ENDPOINT,
+                    body=orjson.dumps(langchain_payload),
+                    headers={"Content-Type": "application/json"},
+                )
+                logger.info("Successfully submitted metadata to LangSmith instance")
+            except Exception as e:
+                submissions_failed.append("langchain")
+                await logger.awarning(
+                    "LangChain metadata submission failed.", error=str(e)
+                )
+
+        if submissions_attempted and len(submissions_failed) == len(
+            submissions_attempted
+        ):
             # retry on next iteration
             incr_runs(incr=runs)
             incr_nodes("", incr=nodes)
             FROM_TIMESTAMP = from_timestamp
-            await logger.ainfo("Metadata submission skipped.", error=str(e))
+            await logger.awarning(
+                "All metadata submissions failed, will retry",
+                attempted=submissions_attempted,
+                failed=submissions_failed,
+            )
+
         await asyncio.sleep(INTERVAL)

{langgraph_api-0.2.77 → langgraph_api-0.2.83}/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.83}/langgraph_api/serde.py

@@ -123,16 +123,18 @@ def _sanitise(o: Any) -> Any:
 
 def json_dumpb(obj) -> bytes:
     try:
-        return orjson.dumps(obj, default=default, option=_option).replace(
-            rb"\u0000", b""
-        )  # null unicode char not allowed in json
+        dumped = orjson.dumps(obj, default=default, option=_option)
     except TypeError as e:
         if "surrogates not allowed" not in str(e):
             raise
-        surrogate_sanitized = _sanitise(obj)
-        return orjson.dumps(
-            surrogate_sanitized, default=default, option=_option
-        ).replace(rb"\u0000", b"")
+        dumped = orjson.dumps(_sanitise(obj), default=default, option=_option)
+    return (
+        # Unfortunately simply doing ``.replace(rb"\\u0000", b"")`` on
+        # the dumped bytes can leave an **orphaned back-slash** (e.g. ``\\q``)
+        # which makes the resulting JSON invalid.  The fix is to delete the *double*
+        # back-slash form **first**, then (optionally) the single-escapes.
+        dumped.replace(rb"\\u0000", b"").replace(rb"\u0000", b"")
+    )
 
 
 def json_loads(content: bytes | Fragment | dict) -> Any:
@@ -154,6 +156,10 @@ class Serializer(JsonPlusSerializer):
         except TypeError:
             return "pickle", cloudpickle.dumps(obj)
 
+    def dumps(self, obj: Any) -> bytes:
+        # See comment above (in json_dumpb)
+        return super().dumps(obj).replace(rb"\\u0000", b"").replace(rb"\u0000", b"")
+
     def loads_typed(self, data: tuple[str, bytes]) -> Any:
         if data[0] == "pickle":
             try:

{langgraph_api-0.2.77 → langgraph_api-0.2.83}/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"