langgraph-api 0.2.85__py3-none-any.whl → 0.2.88__py3-none-any.whl

langgraph_api/__init__.py

@@ -1 +1 @@
-__version__ = "0.2.85"
+__version__ = "0.2.88"

langgraph_api/api/mcp.py

@@ -385,11 +385,12 @@ async def handle_tools_list(
             seen_names.add(name)
 
         schemas = await client.assistants.get_schemas(id_, headers=request.headers)
+        description = assistant.get("description") or ""
         tools.append(
             {
                 "name": name,
                 "inputSchema": schemas.get("input_schema", {}),
-                "description": "",
+                "description": description,
             },
         )
 

langgraph_api/auth/langsmith/backend.py

@@ -23,7 +23,24 @@ class AuthDict(TypedDict):
     user_email: NotRequired[str]
 
 
+class AuthCacheEntry(TypedDict):
+    credentials: AuthCredentials
+    user: StudioUser
+
+
 class LangsmithAuthBackend(AuthenticationBackend):
+    def __init__(self):
+        from langgraph_api.utils.cache import LRUCache
+
+        self._cache = LRUCache[AuthCacheEntry](max_size=1000, ttl=60)
+
+    def _get_cache_key(self, headers):
+        """Generate cache key from authentication headers"""
+        relevant_headers = tuple(
+            (name, value) for name, value in headers if value is not None
+        )
+        return str(hash(relevant_headers))
+
     async def authenticate(
         self, conn: HTTPConnection
     ) -> tuple[AuthCredentials, BaseUser] | None:
@@ -37,6 +54,12 @@ class LangsmithAuthBackend(AuthenticationBackend):
         ]
         if not any(h[1] for h in headers):
             raise AuthenticationError("Missing authentication headers")
+
+        # Check cache first
+        cache_key = self._get_cache_key(headers)
+        if cached_entry := self._cache.get(cache_key):
+            return cached_entry["credentials"], cached_entry["user"]
+
         async with auth_client() as auth:
             if not LANGSMITH_AUTH_VERIFY_TENANT_ID and not conn.headers.get(
                 "x-api-key"
@@ -66,6 +89,10 @@ class LangsmithAuthBackend(AuthenticationBackend):
                 if auth_dict["tenant_id"] != LANGSMITH_TENANT_ID:
                     raise AuthenticationError("Invalid tenant ID")
 
-        return AuthCredentials(["authenticated"]), StudioUser(
-            auth_dict.get("user_id"), is_authenticated=True
-        )
+        credentials = AuthCredentials(["authenticated"])
+        user = StudioUser(auth_dict.get("user_id"), is_authenticated=True)
+
+        # Cache the result
+        self._cache.set(cache_key, AuthCacheEntry(credentials=credentials, user=user))
+
+        return credentials, user

langgraph_api/config.py

@@ -6,6 +6,8 @@ import orjson
 from starlette.config import Config, undefined
 from starlette.datastructures import CommaSeparatedStrings
 
+from langgraph_api import traceblock
+
 # types
 
 
@@ -173,7 +175,7 @@ LANGGRAPH_AES_KEY = env("LANGGRAPH_AES_KEY", default=None, cast=_get_encryption_
 # redis
 REDIS_URI = env("REDIS_URI", cast=str)
 REDIS_CLUSTER = env("REDIS_CLUSTER", cast=bool, default=False)
-REDIS_MAX_CONNECTIONS = env("REDIS_MAX_CONNECTIONS", cast=int, default=500)
+REDIS_MAX_CONNECTIONS = env("REDIS_MAX_CONNECTIONS", cast=int, default=2000)
 REDIS_CONNECT_TIMEOUT = env("REDIS_CONNECT_TIMEOUT", cast=float, default=10.0)
 REDIS_MAX_IDLE_TIME = env("REDIS_MAX_IDLE_TIME", cast=float, default=120.0)
 REDIS_KEY_PREFIX = env("REDIS_KEY_PREFIX", cast=str, default="")
@@ -372,3 +374,5 @@ if not os.getenv("LANGCHAIN_REVISION_ID") and (
     # This is respected by the langsmith SDK env inference
     # https://github.com/langchain-ai/langsmith-sdk/blob/1b93e4c13b8369d92db891ae3babc3e2254f0e56/python/langsmith/env/_runtime_env.py#L190
     os.environ["LANGCHAIN_REVISION_ID"] = ref_sha
+
+traceblock.patch_requests()

langgraph_api/http.py

@@ -120,9 +120,9 @@ def is_retriable_error(exception: Exception) -> bool:
         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
-            and exception.response.status_code >= 500
+        return getattr(exception, "response", None) is not None and (
+            exception.response.status_code >= 500
+            or exception.response.status_code == 429
         )
     return False
 

langgraph_api/js/client.mts

@@ -56,6 +56,7 @@ import {
   getStaticGraphSchema,
 } from "@langchain/langgraph-api/schema";
 import { filterValidExportPath } from "./src/utils/files.mts";
+import { patchFetch } from "./traceblock.mts";
 
 const logger = createLogger({
   level: "debug",
@@ -1114,6 +1115,6 @@ async function getNodesExecutedRequest(
   nodesExecuted = 0;
   return { nodesExecuted: value };
 }
-
+patchFetch();
 asyncExitHook(() => awaitAllCallbacks(), { wait: 3_000 });
 main();

langgraph_api/js/traceblock.mts

@@ -0,0 +1,25 @@
+import { overrideFetchImplementation } from "langsmith";
+
+const RUNS_RE = /^https:\/\/api\.smith\.langchain\.com\/.*runs(\/|$)/i;
+
+export function patchFetch() {
+  const shouldBlock =
+    typeof process !== "undefined" &&
+    !!(process.env && process.env.LANGSMITH_DISABLE_SAAS_RUNS === "true");
+
+  if (shouldBlock) {
+    overrideFetchImplementation(
+      async (input: RequestInfo, init?: RequestInit) => {
+        const req = input instanceof Request ? input : new Request(input, init);
+
+        if (req.method.toUpperCase() === "POST" && RUNS_RE.test(req.url)) {
+          throw new Error(
+            `Policy-blocked POST to ${new URL(req.url).pathname} — run tracking disabled`,
+          );
+        }
+
+        return fetch(req);
+      },
+    );
+  }
+}

langgraph_api/models/run.py

@@ -312,6 +312,7 @@ async def create_valid_run(
     after_seconds = payload.get("after_seconds", 0)
     configurable["__after_seconds__"] = after_seconds
     put_time_start = time.time()
+    if_not_exists = payload.get("if_not_exists", "reject")
     run_coro = Runs.put(
         conn,
         assistant_id,
@@ -337,7 +338,7 @@ async def create_valid_run(
         multitask_strategy=multitask_strategy,
         prevent_insert_if_inflight=prevent_insert_if_inflight,
         after_seconds=after_seconds,
-        if_not_exists=payload.get("if_not_exists", "reject"),
+        if_not_exists=if_not_exists,
     )
     run_ = await run_coro
 
@@ -364,7 +365,7 @@ async def create_valid_run(
             stream_mode=stream_mode,
             temporary=temporary,
             after_seconds=after_seconds,
-            if_not_exists=payload.get("if_not_exists", "reject"),
+            if_not_exists=if_not_exists,
             run_create_ms=(
                 int(time.time() * 1_000) - request_start_time
                 if request_start_time

langgraph_api/traceblock.py

@@ -0,0 +1,22 @@
+import os
+from urllib.parse import urlparse
+
+from requests.sessions import Session
+
+_HOST = "api.smith.langchain.com"
+_PATH_PREFIX = "/runs"
+
+
+def patch_requests():
+    if os.getenv("LANGSMITH_DISABLE_SAAS_RUNS") != "true":
+        return
+    _orig = Session.request
+
+    def _guard(self, method, url, *a, **kw):
+        if method.upper() == "POST":
+            u = urlparse(url)
+            if u.hostname == _HOST and _PATH_PREFIX in u.path:
+                raise RuntimeError(f"POST to {url} blocked by policy")
+        return _orig(self, method, url, *a, **kw)
+
+    Session.request = _guard

langgraph_api/utils/cache.py

@@ -0,0 +1,58 @@
+import asyncio
+import time
+from collections import OrderedDict
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+
+
+class LRUCache(Generic[T]):
+    """LRU cache with TTL support."""
+
+    def __init__(self, max_size: int = 1000, ttl: float = 60):
+        self._cache: OrderedDict[str, tuple[T, float]] = OrderedDict()
+        self._max_size = max_size if max_size > 0 else 1000
+        self._ttl = ttl
+
+    def _get_time(self) -> float:
+        """Get current time, using loop.time() if available for better performance."""
+        try:
+            return asyncio.get_event_loop().time()
+        except RuntimeError:
+            return time.monotonic()
+
+    def get(self, key: str) -> T | None:
+        """Get item from cache, returning None if expired or not found."""
+        if key not in self._cache:
+            return None
+
+        value, timestamp = self._cache[key]
+        if self._get_time() - timestamp >= self._ttl:
+            # Expired, remove and return None
+            del self._cache[key]
+            return None
+
+        # Move to end (most recently used)
+        self._cache.move_to_end(key)
+        return value
+
+    def set(self, key: str, value: T) -> None:
+        """Set item in cache, evicting old entries if needed."""
+        # Remove if already exists (to update timestamp)
+        if key in self._cache:
+            del self._cache[key]
+
+        # Evict oldest entries if needed
+        while len(self._cache) >= self._max_size:
+            self._cache.popitem(last=False)  # Remove oldest (FIFO)
+
+        # Add new entry
+        self._cache[key] = (value, self._get_time())
+
+    def size(self) -> int:
+        """Return current cache size."""
+        return len(self._cache)
+
+    def clear(self) -> None:
+        """Clear all entries from cache."""
+        self._cache.clear()

langgraph_api/worker.py

@@ -113,6 +113,8 @@ async def worker(
         run_creation_ms=run_creation_ms,
         run_queue_ms=ms(run_started_at_dt, run["created_at"]),
         run_stream_start_ms=ms(run_stream_started_at_dt, run_started_at_dt),
+        temporary=temporary,
+        resumable=resumable,
     )
 
     def on_checkpoint(checkpoint_arg: CheckpointPayload):
@@ -242,47 +244,55 @@ async def worker(
                             run_id=str(run_id),
                             run_attempt=attempt,
                         )
-                await Threads.set_joint_status(
-                    conn, run["thread_id"], run_id, status, checkpoint=checkpoint
-                )
+                if not temporary:
+                    await Threads.set_joint_status(
+                        conn, run["thread_id"], run_id, status, checkpoint=checkpoint
+                    )
             elif isinstance(exception, TimeoutError):
                 status = "timeout"
                 await logger.awarning(
                     "Background run timed out",
                     **log_info,
                 )
-                await Threads.set_joint_status(
-                    conn, run["thread_id"], run_id, status, checkpoint=checkpoint
-                )
-            elif isinstance(exception, UserRollback):
-                status = "rollback"
-                try:
+                if not temporary:
                     await Threads.set_joint_status(
                         conn, run["thread_id"], run_id, status, checkpoint=checkpoint
                     )
-                    await logger.ainfo(
-                        "Background run rolled back",
-                        **log_info,
-                    )
-                except HTTPException as e:
-                    if e.status_code == 404:
+            elif isinstance(exception, UserRollback):
+                status = "rollback"
+                if not temporary:
+                    try:
+                        await Threads.set_joint_status(
+                            conn,
+                            run["thread_id"],
+                            run_id,
+                            status,
+                            checkpoint=checkpoint,
+                        )
                         await logger.ainfo(
-                            "Ignoring rollback error for missing run",
+                            "Background run rolled back",
                             **log_info,
                         )
-                    else:
-                        raise
-
-                checkpoint = None  # reset the checkpoint
+                    except HTTPException as e:
+                        if e.status_code == 404:
+                            await logger.ainfo(
+                                "Ignoring rollback error for missing run",
+                                **log_info,
+                            )
+                        else:
+                            raise
+
+                    checkpoint = None  # reset the checkpoint
             elif isinstance(exception, UserInterrupt):
                 status = "interrupted"
                 await logger.ainfo(
                     "Background run interrupted",
                     **log_info,
                 )
-                await Threads.set_joint_status(
-                    conn, run["thread_id"], run_id, status, checkpoint, exception
-                )
+                if not temporary:
+                    await Threads.set_joint_status(
+                        conn, run["thread_id"], run_id, status, checkpoint, exception
+                    )
             elif isinstance(exception, ALL_RETRIABLE_EXCEPTIONS):
                 status = "retry"
                 await logger.awarning(
@@ -290,6 +300,7 @@ async def worker(
                     **log_info,
                 )
                 # Don't update thread status yet.
+                # Apply this even for temporary runs, so we retry
                 await Runs.set_status(conn, run_id, "pending")
             else:
                 status = "error"
@@ -303,13 +314,14 @@ async def worker(
                     exc_info=not isinstance(exception, RemoteException),
                     **log_info,
                 )
-                await Threads.set_joint_status(
-                    conn, run["thread_id"], run_id, status, checkpoint, exception
-                )
+                if not temporary:
+                    await Threads.set_joint_status(
+                        conn, run["thread_id"], run_id, status, checkpoint, exception
+                    )
 
             # delete thread if it's temporary and we don't want to retry
             if temporary and not isinstance(exception, ALL_RETRIABLE_EXCEPTIONS):
-                await Threads.delete(conn, run["thread_id"])
+                await Threads._delete_with_run(conn, run["thread_id"], run_id)
 
         if isinstance(exception, ALL_RETRIABLE_EXCEPTIONS):
             await logger.awarning("RETRYING", exc_info=exception)

{langgraph_api-0.2.85.dist-info → langgraph_api-0.2.88.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.2.85
+Version: 0.2.88
 Author-email: Nuno Campos <nuno@langchain.dev>, Will Fu-Hinthorn <will@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE
@@ -11,7 +11,7 @@ Requires-Dist: httpx>=0.25.0
 Requires-Dist: jsonschema-rs<0.30,>=0.20.0
 Requires-Dist: langchain-core>=0.3.64
 Requires-Dist: langgraph-checkpoint>=2.0.23
-Requires-Dist: langgraph-runtime-inmem<0.4,>=0.3.0
+Requires-Dist: langgraph-runtime-inmem<0.5,>=0.4.0
 Requires-Dist: langgraph-sdk>=0.1.71
 Requires-Dist: langgraph>=0.3.27
 Requires-Dist: langsmith>=0.3.45

{langgraph_api-0.2.85.dist-info → langgraph_api-0.2.88.dist-info}/RECORD

@@ -1,13 +1,13 @@
-langgraph_api/__init__.py,sha256=wU64I3Xh8GFqegDoLD5yhSQwid8d-OGebpjwuhZIE7I,23
+langgraph_api/__init__.py,sha256=KyVs-sgwv8HkCGWN0INHw_LVAcgAVeJmhhH4gGNJ3Ew,23
 langgraph_api/asgi_transport.py,sha256=eqifhHxNnxvI7jJqrY1_8RjL4Fp9NdN4prEub2FWBt8,5091
 langgraph_api/asyncio.py,sha256=qrYEqPRrqtGq7E7KjcMC-ALyN79HkRnmp9rM2TAw9L8,9404
 langgraph_api/cli.py,sha256=-R0fvxg4KNxTkSe7xvDZruF24UMhStJYjpAYlUx3PBk,16018
 langgraph_api/command.py,sha256=3O9v3i0OPa96ARyJ_oJbLXkfO8rPgDhLCswgO9koTFA,768
-langgraph_api/config.py,sha256=-Ij90EaSCW4woYQug0aUp6zVTR0W1oJyYS6jY6hP2ao,11821
+langgraph_api/config.py,sha256=MbsxCitbxI7EQgP7UfSv_MpdYyfQEyKIP1ILYr-MhzU,11889
 langgraph_api/cron_scheduler.py,sha256=CiwZ-U4gDOdG9zl9dlr7mH50USUgNB2Fvb8YTKVRBN4,2625
 langgraph_api/errors.py,sha256=zlnl3xXIwVG0oGNKKpXf1an9Rn_SBDHSyhe53hU6aLw,1858
 langgraph_api/graph.py,sha256=pw_3jVZNe0stO5-Y8kLUuC8EJ5tFqdLu9fLpwUz4Hc4,23574
-langgraph_api/http.py,sha256=WsO9u4s2RHMBaM2No05e5h1Ke3TT7u-_-RP1ITxQ410,5571
+langgraph_api/http.py,sha256=L0leP5fH4NIiFgJd1YPMnTRWqrUUYq_4m5j558UwM5E,5612
 langgraph_api/http_metrics.py,sha256=VgM45yU1FkXuI9CIOE_astxAAu2G-OJ42BRbkcos_CQ,5555
 langgraph_api/logging.py,sha256=LL2LNuMYFrqDhG_KbyKy9AoAPghcdlFj2T50zMyPddk,4182
 langgraph_api/metadata.py,sha256=lfovneEMLA5vTNa61weMkQkiZCtwo-qdwFwqNSj5qVs,6638
@@ -22,13 +22,14 @@ langgraph_api/state.py,sha256=NLl5YgLKppHJ7zfF0bXjsroXmIGCZez0IlDAKNGVy0g,2365
 langgraph_api/store.py,sha256=srRI0fQXNFo_RSUs4apucr4BEp_KrIseJksZXs32MlQ,4635
 langgraph_api/stream.py,sha256=EorM9BD7oiCvkRXlMqnOkBd9P1X3mEagS_oHp-_9aRQ,13669
 langgraph_api/thread_ttl.py,sha256=-Ox8NFHqUH3wGNdEKMIfAXUubY5WGifIgCaJ7npqLgw,1762
+langgraph_api/traceblock.py,sha256=2aWS6TKGTcQ0G1fOtnjVrzkpeGvDsR0spDbfddEqgRU,594
 langgraph_api/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_api/validation.py,sha256=zMuKmwUEBjBgFMwAaeLZmatwGVijKv2sOYtYg7gfRtc,4950
 langgraph_api/webhook.py,sha256=VCJp4dI5E1oSJ15XP34cnPiOi8Ya8Q1BnBwVGadOpLI,1636
-langgraph_api/worker.py,sha256=HHgdwq79gBLFLiIwaFap_TmBigIu3Tfno_SwsjdyjGU,13675
+langgraph_api/worker.py,sha256=Zy6rHfcOoYg7FLui3KDMDMllslXFfjZ3z9uCgae-uMo,14216
 langgraph_api/api/__init__.py,sha256=WHy6oNLWtH1K7AxmmsU9RD-Vm6WP-Ov16xS8Ey9YCmQ,6090
 langgraph_api/api/assistants.py,sha256=w7nXjEknDVHSuP228S8ZLh4bG0nRGnSwVP9pECQOK90,16247
-langgraph_api/api/mcp.py,sha256=RvRYgANqRzNQzSmgjNkq4RlKTtoEJYil04ot9lsmEtE,14352
+langgraph_api/api/mcp.py,sha256=qe10ZRMN3f-Hli-9TI8nbQyWvMeBb72YB1PZVbyqBQw,14418
 langgraph_api/api/meta.py,sha256=fmc7btbtl5KVlU_vQ3Bj4J861IjlqmjBKNtnxSV-S-Q,4198
 langgraph_api/api/openapi.py,sha256=KToI2glOEsvrhDpwdScdBnL9xoLOqkTxx5zKq2pMuKQ,11957
 langgraph_api/api/runs.py,sha256=66x7Nywqr1OoMHHlG03OGuLlrbKYbfvLJepYLg6oXeE,19975
@@ -41,7 +42,7 @@ langgraph_api/auth/middleware.py,sha256=jDA4t41DUoAArEY_PNoXesIUBJ0nGhh85QzRdn5E
 langgraph_api/auth/noop.py,sha256=Bk6Nf3p8D_iMVy_OyfPlyiJp_aEwzL-sHrbxoXpCbac,586
 langgraph_api/auth/studio_user.py,sha256=fojJpexdIZYI1w3awiqOLSwMUiK_M_3p4mlfQI0o-BE,454
 langgraph_api/auth/langsmith/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/auth/langsmith/backend.py,sha256=UNsXa1rXuUJy8fdnasdILIWoxWIlHafY03YJChV0USk,2764
+langgraph_api/auth/langsmith/backend.py,sha256=jRD9WL7OhxnUurMt7v1vziIUwpzkE1hR-xmRaRQmpvw,3617
 langgraph_api/auth/langsmith/client.py,sha256=eKchvAom7hdkUXauD8vHNceBDDUijrFgdTV8bKd7x4Q,3998
 langgraph_api/js/.gitignore,sha256=l5yI6G_V6F1600I1IjiUKn87f4uYIrBAYU1MOyBBhg4,59
 langgraph_api/js/.prettierrc,sha256=0es3ovvyNIqIw81rPQsdt1zCQcOdBqyR_DMbFE4Ifms,19
@@ -49,13 +50,14 @@ langgraph_api/js/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 langgraph_api/js/base.py,sha256=gjY6K8avI03OrI-Hy6a311fQ_EG5r_x8hUYlc7uqxdE,534
 langgraph_api/js/build.mts,sha256=bRQo11cglDFXlLN7Y48CQPTSMLenp7MqIWuP1DkSIo0,3139
 langgraph_api/js/client.http.mts,sha256=AGA-p8J85IcNh2oXZjDxHQ4PnQdJmt-LPcpZp6j0Cws,4687
-langgraph_api/js/client.mts,sha256=N9CTH7mbXGSD-gpv-XyruYsHI-rgrObL8cQoAp5s3_U,30986
+langgraph_api/js/client.mts,sha256=Lyug2cIhW6hlxSaxZV_7KPe1aBLQ47oijbqL26joTT8,31046
 langgraph_api/js/errors.py,sha256=Cm1TKWlUCwZReDC5AQ6SgNIVGD27Qov2xcgHyf8-GXo,361
 langgraph_api/js/global.d.ts,sha256=j4GhgtQSZ5_cHzjSPcHgMJ8tfBThxrH-pUOrrJGteOU,196
 langgraph_api/js/package.json,sha256=BpNAO88mbE-Gv4WzQfj1TLktCWGqm6XBqI892ObuOUw,1333
 langgraph_api/js/remote.py,sha256=B_0cP34AGTW9rL_hJyKIh3P6Z4TvNYNNyc7S2_SOWt4,36880
 langgraph_api/js/schema.py,sha256=7idnv7URlYUdSNMBXQcw7E4SxaPxCq_Oxwnlml8q5ik,408
 langgraph_api/js/sse.py,sha256=lsfp4nyJyA1COmlKG9e2gJnTttf_HGCB5wyH8OZBER8,4105
+langgraph_api/js/traceblock.mts,sha256=QtGSN5VpzmGqDfbArrGXkMiONY94pMQ5CgzetT_bKYg,761
 langgraph_api/js/tsconfig.json,sha256=imCYqVnqFpaBoZPx8k1nO4slHIWBFsSlmCYhO73cpBs,341
 langgraph_api/js/ui.py,sha256=XNT8iBcyT8XmbIqSQUWd-j_00HsaWB2vRTVabwFBkik,2439
 langgraph_api/js/yarn.lock,sha256=hrU_DP2qU9772d2W-FiuA5N7z2eAp6qmkw7dDCAEYhw,85562
@@ -71,13 +73,14 @@ langgraph_api/middleware/http_logger.py,sha256=uroMCag49-uPHTt8K3glkl-0RnWL20YEg
 langgraph_api/middleware/private_network.py,sha256=eYgdyU8AzU2XJu362i1L8aSFoQRiV7_aLBPw7_EgeqI,2111
 langgraph_api/middleware/request_id.py,sha256=SDj3Yi3WvTbFQ2ewrPQBjAV8sYReOJGeIiuoHeZpR9g,1242
 langgraph_api/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/models/run.py,sha256=j1s9KRfFXgjKUudB9z7IVJ34Klo85PPeaVFtmWHhEdo,14514
+langgraph_api/models/run.py,sha256=AAeny3Pjhkw6RCcV5fri8GWjH4Vcy522dLbki6Qbzxo,14523
 langgraph_api/tunneling/cloudflare.py,sha256=iKb6tj-VWPlDchHFjuQyep2Dpb-w2NGfJKt-WJG9LH0,3650
 langgraph_api/utils/__init__.py,sha256=92mSti9GfGdMRRWyESKQW5yV-75Z9icGHnIrBYvdypU,3619
+langgraph_api/utils/cache.py,sha256=SrtIWYibbrNeZzLXLUGBFhJPkMVNQnVxR5giiYGHEfI,1810
 langgraph_api/utils/config.py,sha256=gONI0UsoSpuR72D9lSGAmpr-_iSMDFdD4M_tiXXjmNk,3936
 langgraph_api/utils/future.py,sha256=CGhUb_Ht4_CnTuXc2kI8evEn1gnMKYN0ce9ZyUkW5G4,7251
 langgraph_license/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_license/validation.py,sha256=ZKraAVJArAABKqrmHN-EN18ncoNUmRm500Yt1Sc7tUA,537
+langgraph_license/validation.py,sha256=CU38RUZ5xhP1S8F_y8TNeV6OmtO-tIGjCXbXTwJjJO4,612
 langgraph_runtime/__init__.py,sha256=O4GgSmu33c-Pr8Xzxj_brcK5vkm70iNTcyxEjICFZxA,1075
 langgraph_runtime/checkpoint.py,sha256=J2ePryEyKJWGgxjs27qEHrjj87uPMX3Rqm3hLvG63uk,119
 langgraph_runtime/database.py,sha256=ANEtfm4psr19FtpVcNs5CFWHw-JhfHvIMnkaORa4QSM,117
@@ -90,8 +93,8 @@ langgraph_runtime/store.py,sha256=7mowndlsIroGHv3NpTSOZDJR0lCuaYMBoTnTrewjslw,11
 LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
 logging.json,sha256=3RNjSADZmDq38eHePMm1CbP6qZ71AmpBtLwCmKU9Zgo,379
 openapi.json,sha256=p5tn_cNRiFA0HN3L6JfC9Nm16Hgv-BxvAQcJymKhVWI,143296
-langgraph_api-0.2.85.dist-info/METADATA,sha256=AGw_kM4W7fuNQeG5Kyca-hL-N6xl_QhxPgaHrezkXkE,3891
-langgraph_api-0.2.85.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langgraph_api-0.2.85.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
-langgraph_api-0.2.85.dist-info/licenses/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
-langgraph_api-0.2.85.dist-info/RECORD,,
+langgraph_api-0.2.88.dist-info/METADATA,sha256=EdGed7laJc9m3yltzlxMbMad-sxWqC53jdF_qsdZH4E,3891
+langgraph_api-0.2.88.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langgraph_api-0.2.88.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
+langgraph_api-0.2.88.dist-info/licenses/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
+langgraph_api-0.2.88.dist-info/RECORD,,

langgraph_license/validation.py

@@ -1,5 +1,9 @@
 """Noop license middleware"""
 
+import structlog
+
+logger = structlog.stdlib.get_logger(__name__)
+
 
 async def get_license_status() -> bool:
     """Always return true"""
@@ -17,6 +21,7 @@ async def check_license_periodically(_: int = 60):
     If the license ever fails, you could decide to log,
     raise an exception, or attempt a graceful shutdown.
     """
-    raise NotImplementedError(
+    await logger.ainfo(
         "This is a noop license middleware. No license check is performed."
     )
+    return None