langgraph-api 0.2.134__tar.gz → 0.2.137__tar.gz

{langgraph_api-0.2.134 → langgraph_api-0.2.137}/PKG-INFO

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

{langgraph_api-0.2.134 → langgraph_api-0.2.137}/benchmark/Makefile

@@ -1,14 +1,22 @@
 # Benchmark commands
 benchmark-burst:
+	make benchmark-reset
 	k6 run burst.js
 
 benchmark-ramp:
+	make benchmark-reset
 	k6 run --out json=raw_data_$(shell date +%Y-%m-%dT%H-%M-%S).json ramp.js
 
 benchmark-charts:
 	npm install
 	node graphs.js $(shell ls -t raw_data_*.json | head -1) true
 
+benchmark-reset:
+	node clean.js
+
+benchmark-new-revision:
+	node update-revision.js
+
 benchmark-clean:
 	rm -f results_*.json summary_*.json raw_data_*.json *_chart_*.png
 

langgraph_api-0.2.137/benchmark/clean.js

@@ -0,0 +1,87 @@
+/*
+ * Delete all threads and runs from the last benchmark run for consistent tests
+ * The default benchmark server has a thread TTL of one hour that should clean things up too so this doesn't run too long.
+ */
+
+// URL of your LangGraph server
+const BASE_URL = process.env.BASE_URL || 'http://localhost:9123';
+// LangSmith API key only needed with a custom server endpoint
+const LANGSMITH_API_KEY = process.env.LANGSMITH_API_KEY;
+
+async function clean() {
+    const headers = { 'Content-Type': 'application/json' };
+    if (LANGSMITH_API_KEY) {
+        headers['x-api-key'] = LANGSMITH_API_KEY;
+    }
+
+    const searchUrl = `${BASE_URL}/threads/search`;
+    let totalDeleted = 0;
+
+    try {
+        console.log('Starting thread cleanup...');
+        
+        while (true) {
+            try {
+                // Get the next page of threads
+                console.log('Searching for threads...');
+                const searchResponse = await fetch(searchUrl, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify({
+                        limit: 1000
+                    })
+                });
+
+                if (!searchResponse.ok) {
+                    throw new Error(`Search request failed: ${searchResponse.status} ${searchResponse.statusText}`);
+                }
+
+                const threads = await searchResponse.json();
+                
+                // If no threads found, we're done
+                if (!threads || threads.length === 0) {
+                    console.log('No more threads found.');
+                    break;
+                }
+
+                console.log(`Found ${threads.length} threads to delete`);
+
+                // Delete each thread
+                for (const thread of threads) {
+                    try {
+                        const deleteUrl = `${BASE_URL}/threads/${thread.thread_id}`;
+                        const deleteResponse = await fetch(deleteUrl, {
+                            method: 'DELETE',
+                            headers
+                        });
+
+                        if (!deleteResponse.ok) {
+                            console.error(`Failed to delete thread ${thread.thread_id}: ${deleteResponse.status} ${deleteResponse.statusText}`);
+                        } else {
+                            totalDeleted++;
+                        }
+                    } catch (deleteError) {
+                        console.error(`Error deleting thread ${thread.thread_id}:`, deleteError.message);
+                    }
+                }
+
+                console.log(`Deleted ${threads.length} threads in this batch`);
+
+            } catch (batchError) {
+                console.error('Error in batch processing:', batchError.message);
+                break;
+            }
+        }
+
+        console.log(`Cleanup completed. Total threads deleted: ${totalDeleted}`);
+
+    } catch (error) {
+        console.error('Fatal error during cleanup:', error.message);
+        process.exit(1);
+    }
+}
+
+clean().catch(error => {
+    console.error('Unhandled error:', error.message);
+    process.exit(1);
+});

langgraph_api-0.2.137/benchmark/update-revision.js

@@ -0,0 +1,148 @@
+/*
+ * Trigger a new revision deployment and wait for it to complete
+ * This ensures the benchmark instance is running the latest code
+ */
+
+// LangSmith API endpoints and credentials
+const DEPLOYMENT_ID = process.env.DEPLOYMENT_ID || 'a23f03ff-6d4d-4efd-8149-bb5a7f3b95cf'; // jdr-benchmark deployment id
+const LANGSMITH_API_KEY = process.env.LANGSMITH_API_KEY;
+const API_BASE = 'https://api.host.langchain.com/v1';
+
+// Deployment configuration
+const REVISION_CONFIG = {
+    repo_path: "langgraph.json",
+    env_vars: [
+        {
+            name: "N_JOBS_PER_WORKER",
+            value: "100",
+            value_from: "secret",
+            type: "secret"
+        }
+    ],
+    shareable: false,
+    container_spec: {
+        cpu: null,
+        memory_mb: null,
+        min_scale: 10,
+        max_scale: null
+    }
+};
+
+// Expected deployment statuses in order
+const EXPECTED_STATUSES = ['CREATED', 'AWAITING_BUILD', 'BUILDING', 'AWAITING_DEPLOY', 'DEPLOYING', 'DEPLOYED', 'QUEUED'];
+const FINAL_STATUS = 'DEPLOYED';
+const POLL_INTERVAL = 10000; // 10 seconds
+const MAX_WAIT_TIME = 30 * 60 * 1000; // 30 minutes
+
+async function updateRevision() {
+    if (!LANGSMITH_API_KEY) {
+        console.error('LANGSMITH_API_KEY environment variable is required');
+        process.exit(1);
+    }
+
+    const headers = {
+        'Content-Type': 'application/json',
+        'x-api-key': LANGSMITH_API_KEY
+    };
+
+    const createUrl = `${API_BASE}/projects/${DEPLOYMENT_ID}/revisions`;
+    const pollUrl = `${API_BASE}/projects/${DEPLOYMENT_ID}/revisions?limit=1&offset=0`;
+
+    try {
+        console.log('Triggering new revision deployment...');
+        
+        // Step 1: Create new revision
+        const createResponse = await fetch(createUrl, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(REVISION_CONFIG)
+        });
+
+        if (createResponse.status === 409) {
+            console.log('⚠️  A new revision is already in progress. Continuing to poll existing deployment...');
+        } else if (!createResponse.ok) {
+            throw new Error(`Failed to create revision: ${createResponse.status} ${createResponse.statusText}`);
+        } else {
+            const newRevision = await createResponse.json();
+            const revisionId = newRevision.resource.latest_revision.hosted_langserve_revision_id;
+            console.log(`✓ New revision created: ${revisionId}`);
+            console.log(`Initial status: ${newRevision.status}`);
+        }
+
+        // Step 2: Poll until deployment is complete
+        console.log('\nPolling deployment status...');
+        const startTime = Date.now();
+        let lastStatus = null;
+
+        while (true) {
+            let pollResponse;
+            try {
+                pollResponse = await fetch(pollUrl, {
+                    method: 'GET',
+                    headers
+                });
+
+                if (!pollResponse.ok) {
+                    throw new Error(`Failed to poll revisions: ${pollResponse.status} ${pollResponse.statusText}`);
+                }
+            } catch (pollError) {
+                console.error('Error calling poll endpoint (will retry):', pollError.message);
+                // Wait before next poll and continue
+                await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL));
+                continue;
+            }
+
+            // Parse response and handle deployment logic (these errors should still be thrown)
+            const revisions = await pollResponse.json();
+            
+            if (!revisions || revisions.length === 0) {
+                throw new Error('No revisions found');
+            }
+
+            const latestRevision = revisions[0];
+            const currentStatus = latestRevision.status;
+
+            // Log status changes
+            if (currentStatus !== lastStatus) {
+                const timestamp = new Date().toISOString();
+                console.log(`[${timestamp}] Status: ${currentStatus}`);
+                
+                if (latestRevision.status_message) {
+                    console.log(`  Message: ${latestRevision.status_message}`);
+                }
+                
+                lastStatus = currentStatus;
+            }
+
+            // Check if deployment is complete
+            if (currentStatus === FINAL_STATUS) {
+                console.log(`\n✓ Deployment completed successfully!`);
+                console.log(`Revision ID: ${latestRevision.id}`);
+                console.log(`Total time: ${Math.round((Date.now() - startTime) / 1000)}s`);
+                break;
+            }
+
+            // Check for failure statuses
+            if (!EXPECTED_STATUSES.includes(currentStatus)) {
+                throw new Error(`Deployment failed with status: ${currentStatus}${latestRevision.status_message ? ` - ${latestRevision.status_message}` : ''}`);
+            }
+
+            // Check timeout
+            if (Date.now() - startTime > MAX_WAIT_TIME) {
+                throw new Error(`Deployment timeout after ${MAX_WAIT_TIME / 60000} minutes. Last status: ${currentStatus}`);
+            }
+
+            // Wait before next poll
+            await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL));
+        }
+
+    } catch (error) {
+        console.error('Fatal error during revision update:', error.message);
+        process.exit(1);
+    }
+}
+
+updateRevision().catch(error => {
+    console.error('Unhandled error:', error.message);
+    process.exit(1);
+});

{langgraph_api-0.2.134 → langgraph_api-0.2.137}/healthcheck.py

@@ -3,6 +3,7 @@ import os
 import urllib.request
 
 prefix = ""
+mount_prefix = None
 # Override prefix if it's set in the http config
 if (http := os.environ.get("LANGGRAPH_HTTP")) and (
     mount_prefix := json.loads(http).get("mount_prefix")

langgraph_api-0.2.137/langgraph_api/__init__.py

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

{langgraph_api-0.2.134 → langgraph_api-0.2.137}/langgraph_api/api/assistants.py

@@ -82,9 +82,12 @@ def _get_configurable_jsonschema(graph: Pregel) -> dict:
                 json_schema["properties"].pop(key, None)
         # The type name of the configurable type is not preserved.
         # We'll add it back to the schema if we can.
-        if hasattr(graph, "config_type") and graph.config_type is not None:
-            if hasattr(graph.config_type, "__name__"):
-                json_schema["title"] = graph.config_type.__name__
+        if (
+            hasattr(graph, "config_type")
+            and graph.config_type is not None
+            and hasattr(graph.config_type, "__name__")
+        ):
+            json_schema["title"] = graph.config_type.__name__
         return json_schema
     # If the schema does not have a configurable field, return an empty schema.
     return {}
@@ -263,18 +266,16 @@ async def get_assistant_graph(
             drawable_graph = await graph.fetch_graph(xray=xray)
             json_graph = drawable_graph.to_json()
             for node in json_graph.get("nodes", []):
-                if data := node.get("data"):
-                    if isinstance(data, dict):
-                        data.pop("id", None)
+                if (data := node.get("data")) and isinstance(data, dict):
+                    data.pop("id", None)
             return ApiResponse(json_graph)
 
         try:
             drawable_graph = await graph.aget_graph(xray=xray)
             json_graph = drawable_graph.to_json()
             for node in json_graph.get("nodes", []):
-                if data := node.get("data"):
-                    if isinstance(data, dict):
-                        data.pop("id", None)
+                if (data := node.get("data")) and isinstance(data, dict):
+                    data.pop("id", None)
             return ApiResponse(json_graph)
         except NotImplementedError:
             raise HTTPException(

{langgraph_api-0.2.134 → langgraph_api-0.2.137}/langgraph_api/api/runs.py

@@ -212,9 +212,11 @@ async def wait_run(request: ApiRequest):
             )
         ) as stream:
             async for mode, chunk, _ in stream:
-                if mode == b"values":
-                    vchunk = chunk
-                elif mode == b"updates" and b"__interrupt__" in chunk:
+                if (
+                    mode == b"values"
+                    or mode == b"updates"
+                    and b"__interrupt__" in chunk
+                ):
                     vchunk = chunk
                 elif mode == b"error":
                     vchunk = orjson.dumps({"__error__": orjson.Fragment(chunk)})
@@ -295,9 +297,11 @@ async def wait_run_stateless(request: ApiRequest):
             )
         ) as stream:
             async for mode, chunk, _ in stream:
-                if mode == b"values":
-                    vchunk = chunk
-                elif mode == b"updates" and b"__interrupt__" in chunk:
+                if (
+                    mode == b"values"
+                    or mode == b"updates"
+                    and b"__interrupt__" in chunk
+                ):
                     vchunk = chunk
                 elif mode == b"error":
                     vchunk = orjson.dumps({"__error__": orjson.Fragment(chunk)})

{langgraph_api-0.2.134 → langgraph_api-0.2.137}/langgraph_api/api/store.py

@@ -134,6 +134,7 @@ async def list_namespaces(request: ApiRequest):
     payload = await request.json(StoreListNamespacesRequest)
     prefix = tuple(payload["prefix"]) if payload.get("prefix") else None
     suffix = tuple(payload["suffix"]) if payload.get("suffix") else None
+    err = None
     if prefix and (err := _validate_namespace(prefix)):
         return err
     if suffix and (err := _validate_namespace(suffix)):

{langgraph_api-0.2.134 → langgraph_api-0.2.137}/langgraph_api/asyncio.py

@@ -1,7 +1,7 @@
 import asyncio
 import concurrent.futures
 from collections.abc import AsyncIterator, Coroutine
-from contextlib import AbstractAsyncContextManager
+from contextlib import AbstractAsyncContextManager, suppress
 from functools import partial
 from typing import Any, Generic, TypeVar
 
@@ -26,10 +26,8 @@ def get_event_loop() -> asyncio.AbstractEventLoop:
 
 
 async def sleep_if_not_done(delay: float, done: asyncio.Event) -> None:
-    try:
+    with suppress(TimeoutError):
         await asyncio.wait_for(done.wait(), delay)
-    except TimeoutError:
-        pass
 
 
 class ValueEvent(asyncio.Event):
@@ -95,14 +93,13 @@ PENDING_TASKS = set()
 
 
 def _create_task_done_callback(
-    ignore_exceptions: tuple[Exception, ...],
+    ignore_exceptions: tuple[type[Exception], ...],
     task: asyncio.Task | asyncio.Future,
 ) -> None:
     PENDING_TASKS.discard(task)
     try:
-        if exc := task.exception():
-            if not isinstance(exc, ignore_exceptions):
-                logger.exception("asyncio.task failed", exc_info=exc)
+        if (exc := task.exception()) and not isinstance(exc, ignore_exceptions):
+            logger.exception("asyncio.task failed", exc_info=exc)
     except asyncio.CancelledError:
         pass
 
@@ -176,16 +173,13 @@ class SimpleTaskGroup(AbstractAsyncContextManager["SimpleTaskGroup"]):
         self.taskgroup_name = f" {taskgroup_name} " if taskgroup_name else ""
 
     def _create_task_done_callback(
-        self, ignore_exceptions: tuple[Exception, ...], task: asyncio.Task
+        self, ignore_exceptions: tuple[type[Exception], ...], task: asyncio.Task
     ) -> None:
-        try:
+        with suppress(AttributeError):
             self.tasks.remove(task)
-        except AttributeError:
-            pass
         try:
-            if exc := task.exception():
-                if not isinstance(exc, ignore_exceptions):
-                    logger.exception("asyncio.task failed in task group", exc_info=exc)
+            if (exc := task.exception()) and not isinstance(exc, ignore_exceptions):
+                logger.exception("asyncio.task failed in task group", exc_info=exc)
         except asyncio.CancelledError:
             pass
 
@@ -286,13 +280,8 @@ class AsyncQueue(Generic[T], asyncio.Queue[T]):
                 await getter
             except:
                 getter.cancel()  # Just in case getter is not done yet.
-                try:
-                    # Clean self._getters from canceled getters.
+                with suppress(ValueError):
                     self._getters.remove(getter)
-                except ValueError:
-                    # The getter could be removed from self._getters by a
-                    # previous put_nowait call.
-                    pass
                 if not self.empty() and not getter.cancelled():
                     # We were woken up by put_nowait(), but can't take
                     # the call.  Wake up the next in line.

{langgraph_api-0.2.134 → langgraph_api-0.2.137}/langgraph_api/auth/custom.py

@@ -239,14 +239,11 @@ def _get_custom_auth_middleware(
 
 @functools.lru_cache(maxsize=1)
 def _get_auth_instance(path: str | None = None) -> Auth | Literal["js"] | None:
-    if path is not None:
-        auth_instance = _load_auth_obj(path)
-    else:
-        auth_instance = None
+    auth_instance = _load_auth_obj(path) if path is not None else None
 
     if auth_instance == "js":
         return auth_instance
-
+    deps = None
     if auth_instance is not None and (
         deps := _get_dependencies(auth_instance._authenticate_handler)
     ):
@@ -525,6 +522,12 @@ class ProxyUser(BaseUser):
         """Proxy any other attributes to the underlying user object."""
         return getattr(self._user, name)
 
+    def __iter__(self):
+        return iter(self._user)
+
+    def __len__(self):
+        return len(self._user)
+
     def __str__(self) -> str:
         return f"{self._user}"
 

{langgraph_api-0.2.134 → langgraph_api-0.2.137}/langgraph_api/auth/langsmith/backend.py

@@ -86,9 +86,10 @@ class LangsmithAuthBackend(AuthenticationBackend):
             # If tenant id verification is disabled, the bearer token requests
             # are not required to match the tenant id. Api key requests are
             # always required to match the tenant id.
-            if LANGSMITH_AUTH_VERIFY_TENANT_ID or conn.headers.get("x-api-key"):
-                if auth_dict["tenant_id"] != LANGSMITH_TENANT_ID:
-                    raise AuthenticationError("Invalid tenant ID")
+            if (
+                LANGSMITH_AUTH_VERIFY_TENANT_ID or conn.headers.get("x-api-key")
+            ) and auth_dict["tenant_id"] != LANGSMITH_TENANT_ID:
+                raise AuthenticationError("Invalid tenant ID")
 
         credentials = AuthCredentials(["authenticated"])
         user = StudioUser(auth_dict.get("user_id"), is_authenticated=True)

{langgraph_api-0.2.134 → langgraph_api-0.2.137}/langgraph_api/auth/langsmith/client.py

@@ -1,5 +1,5 @@
 from collections.abc import AsyncGenerator
-from contextlib import asynccontextmanager
+from contextlib import asynccontextmanager, suppress
 from typing import Any
 
 import httpx
@@ -17,11 +17,10 @@ _client: "JsonHttpClient"
 def is_retriable_error(exception: BaseException) -> bool:
     if isinstance(exception, httpx.TransportError):
         return True
-    if isinstance(exception, httpx.HTTPStatusError):
-        if exception.response.status_code > 499:
-            return True
-
-    return False
+    return (
+        isinstance(exception, httpx.HTTPStatusError)
+        and exception.response.status_code > 499
+    )
 
 
 retry_httpx = retry(
@@ -106,10 +105,8 @@ def create_client() -> JsonHttpClient:
 async def close_auth_client() -> None:
     """Close the auth http client."""
     global _client
-    try:
+    with suppress(NameError):
         await _client.client.aclose()
-    except NameError:
-        pass
 
 
 async def initialize_auth_client() -> None:
@@ -132,10 +129,7 @@ async def auth_client() -> AsyncGenerator[JsonHttpClient, None]:
             await client.client.aclose()
     else:
         try:
-            if not _client.client.is_closed:
-                found = True
-            else:
-                found = False
+            found = bool(not _client.client.is_closed)
         except NameError:
             found = False
         if found:

{langgraph_api-0.2.134 → langgraph_api-0.2.137}/langgraph_api/config.py

@@ -242,9 +242,12 @@ CORS_CONFIG: CorsConfig | None = env("CORS_CONFIG", cast=_parse_json, default=No
     }
 }
 """
-if CORS_CONFIG is not None and CORS_ALLOW_ORIGINS != "*":
-    if CORS_CONFIG.get("allow_origins") is None:
-        CORS_CONFIG["allow_origins"] = CORS_ALLOW_ORIGINS
+if (
+    CORS_CONFIG is not None
+    and CORS_ALLOW_ORIGINS != "*"
+    and CORS_CONFIG.get("allow_origins") is None
+):
+    CORS_CONFIG["allow_origins"] = CORS_ALLOW_ORIGINS
 
 # queue
 
@@ -371,7 +374,7 @@ API_VARIANT = env("LANGSMITH_LANGGRAPH_API_VARIANT", cast=str, default="")
 # UI
 UI_USE_BUNDLER = env("LANGGRAPH_UI_BUNDLER", cast=bool, default=False)
 IS_QUEUE_ENTRYPOINT = False
-
+ref_sha = None
 if not os.getenv("LANGCHAIN_REVISION_ID") and (
     ref_sha := os.getenv("LANGSMITH_LANGGRAPH_GIT_REF_SHA")
 ):

{langgraph_api-0.2.134 → langgraph_api-0.2.137}/langgraph_api/cron_scheduler.py

@@ -46,12 +46,11 @@ async def cron_scheduler():
                                         cron["cron_id"],
                                     )
                                 )
-                        except Exception as e:
-                            logger.error(
+                        except Exception:
+                            logger.exception(
                                 "Error scheduling cron run cron_id={}".format(
                                     cron["cron_id"]
-                                ),
-                                exc_info=e,
+                                )
                             )
                         next_run_date = await run_in_executor(
                             None, next_cron_date, cron["schedule"], cron["now"]
@@ -63,6 +62,6 @@ async def cron_scheduler():
             await asyncio.sleep(SLEEP_TIME)
         except asyncio.CancelledError:
             raise
-        except Exception as e:
-            logger.error("Error in cron_scheduler", exc_info=e)
+        except Exception:
+            logger.exception("Error in cron_scheduler")
             await asyncio.sleep(SLEEP_TIME + random())

{langgraph_api-0.2.134 → langgraph_api-0.2.137}/langgraph_api/http.py

@@ -1,4 +1,5 @@
 import asyncio
+import contextlib
 
 import httpx
 from tenacity import (
@@ -65,10 +66,8 @@ class JsonHttpClient:
                 res.raise_for_status()
         finally:
             # We don't need the response body, so we close the response
-            try:
+            with contextlib.suppress(UnboundLocalError):
                 await res.aclose()
-            except UnboundLocalError:
-                pass
 
 
 _http_client: JsonHttpClient
@@ -173,10 +172,7 @@ async def http_request(
 
     content = None
     if body is not None:
-        if isinstance(body, str):
-            content = body.encode("utf-8")
-        else:
-            content = body
+        content = body.encode("utf-8") if isinstance(body, str) else body
     elif json is not None:
         content = json_dumpb(json)