langgraph-api 0.2.83__py3-none-any.whl → 0.2.86__py3-none-any.whl

langgraph_api/__init__.py

@@ -1 +1 @@
-__version__ = "0.2.83"
+__version__ = "0.2.86"

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/api/meta.py

@@ -1,3 +1,4 @@
+import langgraph.version
 from starlette.responses import JSONResponse, PlainTextResponse
 
 from langgraph_api import __version__, config, metadata
@@ -16,6 +17,7 @@ async def meta_info(request: ApiRequest):
     return JSONResponse(
         {
             "version": __version__,
+            "langgraph_py_version": langgraph.version.__version__,
             "flags": {
                 "assistants": True,
                 "crons": plus and config.FF_CRONS_ENABLED,

langgraph_api/api/runs.py

@@ -172,6 +172,7 @@ async def wait_run(request: ApiRequest):
     """Create a run, wait for the output."""
     thread_id = request.path_params["thread_id"]
     payload = await request.json(RunCreateStateful)
+    on_disconnect = payload.get("on_disconnect", "continue")
     run_id = uuid6()
     sub = asyncio.create_task(Runs.Stream.subscribe(run_id))
 
@@ -197,7 +198,10 @@ async def wait_run(request: ApiRequest):
         vchunk: bytes | None = None
         async with aclosing(
             Runs.Stream.join(
-                run["run_id"], thread_id=run["thread_id"], stream_mode=await sub
+                run["run_id"],
+                thread_id=run["thread_id"],
+                stream_mode=await sub,
+                cancel_on_disconnect=on_disconnect == "cancel",
             )
         ) as stream:
             async for mode, chunk, _ in stream:
@@ -248,6 +252,7 @@ async def wait_run(request: ApiRequest):
 async def wait_run_stateless(request: ApiRequest):
     """Create a stateless run, wait for the output."""
     payload = await request.json(RunCreateStateless)
+    on_disconnect = payload.get("on_disconnect", "continue")
     run_id = uuid6()
     sub = asyncio.create_task(Runs.Stream.subscribe(run_id))
 
@@ -277,6 +282,7 @@ async def wait_run_stateless(request: ApiRequest):
                 thread_id=run["thread_id"],
                 stream_mode=await sub,
                 ignore_404=True,
+                cancel_on_disconnect=on_disconnect == "cancel",
             )
         ) as stream:
             async for mode, chunk, _ in stream:

langgraph_api/auth/langsmith/backend.py

@@ -14,6 +14,7 @@ from langgraph_api.config import (
     LANGSMITH_AUTH_VERIFY_TENANT_ID,
     LANGSMITH_TENANT_ID,
 )
+from langgraph_api.utils.cache import LRUCache
 
 
 class AuthDict(TypedDict):
@@ -23,7 +24,22 @@ class AuthDict(TypedDict):
     user_email: NotRequired[str]
 
 
+class AuthCacheEntry(TypedDict):
+    credentials: AuthCredentials
+    user: StudioUser
+
+
 class LangsmithAuthBackend(AuthenticationBackend):
+    def __init__(self):
+        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 +53,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 +88,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

@@ -173,7 +173,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="")

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/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

@@ -307,23 +307,9 @@ async def worker(
                     conn, run["thread_id"], run_id, status, checkpoint, exception
                 )
 
-            # delete or set status of thread
-            if not isinstance(exception, ALL_RETRIABLE_EXCEPTIONS):
-                if temporary:
-                    await Threads.delete(conn, run["thread_id"])
-                else:
-                    try:
-                        await Threads.set_status(
-                            conn, run["thread_id"], checkpoint, exception
-                        )
-                    except HTTPException as e:
-                        if e.status_code == 404:
-                            await logger.ainfo(
-                                "Ignoring set_status error for missing thread",
-                                exc=str(e),
-                            )
-                        else:
-                            raise
+            # 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"])
 
         if isinstance(exception, ALL_RETRIABLE_EXCEPTIONS):
             await logger.awarning("RETRYING", exc_info=exception)

{langgraph_api-0.2.83.dist-info → langgraph_api-0.2.86.dist-info}/METADATA

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

{langgraph_api-0.2.83.dist-info → langgraph_api-0.2.86.dist-info}/RECORD

@@ -1,13 +1,13 @@
-langgraph_api/__init__.py,sha256=pjPizgc1F0inosPx3drrKz6OVCqyJA5RpGxHjw1BzHI,23
+langgraph_api/__init__.py,sha256=UX0NFs_UycABtPhNbHs9Deehd2GdHX9DySKa6T9arUg,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=j4nohZGUGybr36BtuM72K1phOQjUBEx6_2h77BB78Vs,11822
 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
@@ -25,13 +25,13 @@ langgraph_api/thread_ttl.py,sha256=-Ox8NFHqUH3wGNdEKMIfAXUubY5WGifIgCaJ7npqLgw,1
 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=fL0pNEW9FaldEREq_4L-ivkxTr2R_rEpmVMi-zRx__U,14226
+langgraph_api/worker.py,sha256=HHgdwq79gBLFLiIwaFap_TmBigIu3Tfno_SwsjdyjGU,13675
 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/meta.py,sha256=LnDyfO-YJx8WbFS7VR6LCeB8zL5vxH6vFHd87aqHnjk,4106
+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=1rNUbFleakTYAqG20cGtpWyY2TS5EoVgT4Pxe1AQ68E,19692
+langgraph_api/api/runs.py,sha256=66x7Nywqr1OoMHHlG03OGuLlrbKYbfvLJepYLg6oXeE,19975
 langgraph_api/api/store.py,sha256=TSeMiuMfrifmEnEbL0aObC2DPeseLlmZvAMaMzPgG3Y,5535
 langgraph_api/api/threads.py,sha256=ogMKmEoiycuaV3fa5kpupDohJ7fwUOfVczt6-WSK4FE,9322
 langgraph_api/api/ui.py,sha256=2nlipYV2nUGR4T9pceaAbgN1lS3-T2zPBh7Nv3j9eZQ,2479
@@ -41,7 +41,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=bmTbbb4UGfO244sDRStxdB78IdQCJuX08Rhs3Bl7iag,3608
 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
@@ -74,10 +74,11 @@ langgraph_api/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 langgraph_api/models/run.py,sha256=j1s9KRfFXgjKUudB9z7IVJ34Klo85PPeaVFtmWHhEdo,14514
 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 +91,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.83.dist-info/METADATA,sha256=KgKghdie5R6f4M5GUiDpMumPq7bShgf7TmuSpRRZzps,3891
-langgraph_api-0.2.83.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langgraph_api-0.2.83.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
-langgraph_api-0.2.83.dist-info/licenses/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
-langgraph_api-0.2.83.dist-info/RECORD,,
+langgraph_api-0.2.86.dist-info/METADATA,sha256=kYoKk78nUSCT6BKYrjpYPBGF7GFFNODJLvxx6wToGD8,3891
+langgraph_api-0.2.86.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langgraph_api-0.2.86.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
+langgraph_api-0.2.86.dist-info/licenses/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
+langgraph_api-0.2.86.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