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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.2.78
+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.78 → 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.78 → 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.78 → 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.78 → 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.78 → langgraph_api-0.2.83}/langgraph_api/config.py

@@ -155,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.78 → 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.78 → langgraph_api-0.2.83}/langgraph_api/metadata.py

@@ -55,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:
@@ -82,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
@@ -102,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": {
@@ -130,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.78 → 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.78/langgraph_api/__init__.py

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