langgraph-api 0.2.129__tar.gz → 0.2.132__tar.gz

{langgraph_api-0.2.129 → langgraph_api-0.2.132}/Makefile

@@ -5,6 +5,7 @@
 lint:
 	uv run ruff check .
 	uv run ruff format . --diff
+	uvx ty check --exclude "**/pb/**" --exclude "**/*_test.py" --exclude "**/test_*.py" --exclude "**/tests/**" --exclude "venv/**" --exclude ".venv/**" --exclude "build/**" --exclude "dist/**" .
 
 format:
 	uv run ruff check --fix .
@@ -113,4 +114,4 @@ start-auth-fastapi-jwt:
 VERSION_KIND ?= patch
 
 bump-version:
-	uv run --with hatch hatch version $(VERSION_KIND)
+	uv run --with hatch hatch version $(VERSION_KIND)

{langgraph_api-0.2.129 → langgraph_api-0.2.132}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.2.129
+Version: 0.2.132
 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.7,>=0.6.9
+Requires-Dist: langgraph-runtime-inmem<0.7,>=0.6.13
 Requires-Dist: langgraph-sdk>=0.2.0
 Requires-Dist: langgraph>=0.4.0
 Requires-Dist: langsmith>=0.3.45

langgraph_api-0.2.132/benchmark/.gitignore

@@ -0,0 +1,10 @@
+# K6 summary and results files
+results_*.json
+summary_*.json
+raw_data_*.json
+
+# Generated chart files
+*_chart_*.png
+
+# Node.js dependencies
+node_modules/

langgraph_api-0.2.132/benchmark/Makefile

@@ -0,0 +1,16 @@
+# Benchmark commands
+benchmark-burst:
+	k6 run burst.js
+
+benchmark-ramp:
+	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-clean:
+	rm -f results_*.json summary_*.json raw_data_*.json *_chart_*.png
+
+benchmark-clean-charts:
+	rm -f *_chart_*.png

{langgraph_api-0.2.129 → langgraph_api-0.2.132}/benchmark/README.md

@@ -12,8 +12,8 @@ There are two modes of testing available:
         BURST_SIZE - How many requests to run. Default: 100
 2. `Ramp` - Scale up the number of /run/wait requests and then plateau.
     Available Params:
-        LOAD_SIZE - How much traffic to ramp up over a 60s period. Default: 100
-        LEVELS - The number of times to ramp up. Default: 10
+        LOAD_SIZE - How much traffic to ramp up over a 60s period. Default: 500
+        LEVELS - The number of times to ramp up. Default: 2
         PLATEAU_DURATION - How long to sustain the max level of traffic in seconds. Default: 300
 
 ### Agent
@@ -65,6 +65,8 @@ make benchmark-clean
 
 Summary results are written to stdout and persisted in a summary_burst file. More detailed results for the same burst are persisted in a results_burst file.
 
+Charts can be created from the run locally using the `make benchmark-charts` command.
+
 ## Resources
 
 - [K6 Documentation](https://k6.io/docs/)

{langgraph_api-0.2.129 → langgraph_api-0.2.132}/benchmark/burst.js

@@ -139,7 +139,8 @@ export default function() {
 export function setup() {
   console.log(`Starting burst benchmark`);
   console.log(`Running on pod: ${__ENV.POD_NAME || 'local'}`);
-  console.log(`Burst size: ${BURST_SIZE}`);
+  console.log(`Running with the following burst config: burst size ${BURST_SIZE}`);
+  console.log(`Running with the following agent config: data size ${DATA_SIZE}, delay ${DELAY}, expand ${EXPAND}, mode ${MODE}`);
 
   return { startTime: new Date().toISOString() };
 }

langgraph_api-0.2.132/benchmark/graphs.js

@@ -0,0 +1,236 @@
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const QuickChart = require('quickchart-js');
+const { plot } = require('nodeplotlib');
+
+// Function to save chart using Quickchart
+async function saveChartWithQuickchart(chartData, chartLayout, filename) {
+  const chart = new QuickChart();
+
+  chart.setWidth(800);
+  chart.setHeight(500);
+  chart.setFormat('png');
+
+  const config = {
+    type: 'line',
+    data: {
+      labels: chartData[0].x,
+      datasets: chartData.map(metric => {
+        return {
+            label: metric.name,
+            data: metric.y
+        }
+      })
+    }
+  };
+
+  chart.setConfig(config);
+
+  try {
+    const imageBuffer = await chart.toBinary();
+    fs.writeFileSync(filename, imageBuffer);
+    console.log(`Chart saved to ${filename}`);
+  } catch (error) {
+    console.error(`Error saving chart to ${filename}:`, error.message);
+  }
+}
+
+/**
+ * Function to generate charts from benchmark results
+ * 
+ * Graphs that we generate:
+ * - VU scaling over time
+ * - Requests over time, broken into success and failure by reason
+ * - Average run duration over time
+ * 
+ * Useful but currently in deployment dashboard:
+ * - Connection use over time (postgres, redis)
+ * - IOPS over time (postgres, redis)
+ * - Workers in use over time
+ * 
+ * Dashboard: https://smith.langchain.com/o/ebbaf2eb-769b-4505-aca2-d11de10372a4/host/deployments/a23f03ff-6d4d-4efd-8149-bb5a7f3b95cf?tab=2&paginationModel=%7B%22pageIndex%22%3A0%2C%22pageSize%22%3A10%7D#
+ */
+async function generateCharts(rawDataFile, displayInBrowser = false) {
+    console.log("Generating charts for", rawDataFile);
+    const aggregatedData = {};
+
+    // Read the results and summary files
+    const fileStream = fs.createReadStream(rawDataFile, 'utf8');
+    const rl = readline.createInterface({
+        input: fileStream,
+        crlfDelay: Infinity
+    });
+
+    for await (const line of rl) {
+        const entry = JSON.parse(line);
+
+        // Always written before the first point for that metric
+        if (entry.type === 'Metric') {
+            const metricName = entry.metric;
+            aggregatedData[metricName] = {};
+        } else if (entry.type === 'Point') {
+            const metricName = entry.metric;
+            const metricValue = entry.data.value;
+            const timestamp = Date.parse(entry.data.time);
+
+            // Round timestamp to 10-second intervals
+            const roundedTimestamp = Math.floor(timestamp / 10000) * 10000;
+
+            if (!aggregatedData[metricName][roundedTimestamp]) {
+                aggregatedData[metricName][roundedTimestamp] = [];
+            }
+            aggregatedData[metricName][roundedTimestamp].push(metricValue);
+        } else {
+            throw new Error(`Unexpected row type: ${entry.type}`);
+        }
+    }
+
+    // Convert aggregated data to final format with averages
+    const finalData = {};
+    for (const [metricName, timestampBuckets] of Object.entries(aggregatedData)) {
+        finalData[metricName] = [];
+        for (const [timestamp, values] of Object.entries(timestampBuckets)) {
+            const average = values.reduce((sum, val) => sum + val, 0) / values.length;
+            const max = Math.max(...values);
+            finalData[metricName].push({ 
+                timestamp: timestamp,
+                average: average,
+                max: max,
+                count: values.length
+            });
+        }
+        // Sort by timestamp
+        finalData[metricName].sort((a, b) => a.timestamp - b.timestamp);
+    }
+
+    // Create the charts
+    // We always get a http_reqs metric as one of the first
+    const firstTimestamp = finalData['http_reqs'][0].timestamp;
+
+    // Failed requests won't always be present
+    const data = [
+        {
+            x: finalData['http_reqs'].map(d => (d.timestamp - firstTimestamp) / 1000),
+            y: finalData['http_reqs'].map(d => d.count),
+            type: 'scatter',
+            mode: 'lines',
+            name: 'Total Requests',
+        },
+        {
+            x: finalData['successful_runs'].map(d => (d.timestamp - firstTimestamp) / 1000),
+            y: finalData['successful_runs'].map(d => d.count),
+            type: 'scatter',
+            mode: 'lines',
+            name: 'Success Rate',
+        }
+    ]
+    if (finalData['failed_runs']) {
+        data.push({
+            x: finalData['failed_runs'].map(d => (d.timestamp - firstTimestamp) / 1000),
+            y: finalData['failed_runs'].map(d => d.count),
+            type: 'scatter',
+            mode: 'lines',
+            name: 'Failed Requests',
+        })
+    }
+
+    const requestsChart = {
+        data,
+        layout: {
+        title: {
+            text: 'Success Rate Over Time',
+        },
+        xaxis: { 
+            title: 'Time (10 second intervals)',
+        },
+        yaxis: { 
+            title: 'Call Counts',
+        }
+        }
+    };
+
+    const runDurationChart = {
+        data: [
+        {
+            x: finalData['run_duration'].map(d => (d.timestamp - firstTimestamp) / 1000),
+            y: finalData['run_duration'].map(d => d.average),
+            type: 'scatter',
+            mode: 'lines',
+            name: 'Run Duration',
+        }
+        ],
+        layout: {
+        title: {
+            text: 'Run Duration Over Time',
+        },
+        xaxis: { 
+            title: 'Time (10 second intervals)',
+        },
+        yaxis: { 
+            title: 'Run Duration (ms)',
+        },
+        }
+    }
+
+    const vusChart = {
+        data: [
+        {
+            x: finalData['vus'].map(d => (d.timestamp - firstTimestamp) / 1000),
+            y: finalData['vus'].map(d => d.max),
+            type: 'scatter',
+            mode: 'lines',
+            name: 'Concurrent Virtual Users',
+        }
+        ],
+        layout: {
+        title: {
+            text: 'Concurrent Virtual Users over Time',
+        },
+        xaxis: { 
+            title: 'Time (10 second intervals)',
+        },
+        yaxis: { 
+            title: 'VUs (max)',
+        },
+        }
+    }
+
+    // Always save charts as images using Quickchart
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const requestsImagePath = path.join(__dirname, `requests_chart_${timestamp}.png`);
+    const runDurationImagePath = path.join(__dirname, `run_duration_chart_${timestamp}.png`);
+    const vusImagePath = path.join(__dirname, `vus_chart_${timestamp}.png`);
+
+    // Save charts using Quickchart
+    await saveChartWithQuickchart(requestsChart.data, requestsChart.layout, requestsImagePath);
+    await saveChartWithQuickchart(runDurationChart.data, runDurationChart.layout, runDurationImagePath);
+    await saveChartWithQuickchart(vusChart.data, vusChart.layout, vusImagePath);
+
+    // Display in CLI if requested
+    if (displayInBrowser) {
+        plot(requestsChart.data, requestsChart.layout);
+        plot(runDurationChart.data, runDurationChart.layout);
+        plot(vusChart.data, vusChart.layout);
+    }
+    
+    console.log(`Charts generated: ${vusImagePath}, ${requestsImagePath}, ${runDurationImagePath}`);
+}
+
+// CLI usage
+if (require.main === module) {
+  const [,, rawDataFile, displayInBrowser] = process.argv;
+  
+  if (!rawDataFile) {
+    console.error('Usage: node graphs.js <raw-data-file>');
+    process.exit(1);
+  }
+  
+  generateCharts(rawDataFile, displayInBrowser)
+    .catch(error => {
+      console.error('Failed to generate charts:', error);
+      process.exit(1);
+    });
+}
+
+module.exports = { generateCharts };

langgraph_api-0.2.132/benchmark/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "benchmark-charts",
+  "version": "1.0.0",
+  "description": "Chart generation for K6 benchmark results",
+  "main": "graphs.js",
+  "scripts": {
+    "generate-charts": "node graphs.js"
+  },
+  "dependencies": {
+    "nodeplotlib": "^1.0.4",
+    "quickchart-js": "^3.1.3"
+  },
+  "devDependencies": {},
+  "engines": {
+    "node": ">=14.0.0"
+  }
+} 

{langgraph_api-0.2.129 → langgraph_api-0.2.132}/benchmark/ramp.js

@@ -18,9 +18,10 @@ const BASE_URL = __ENV.BASE_URL || 'http://localhost:9123';
 const LANGSMITH_API_KEY = __ENV.LANGSMITH_API_KEY;
 
 // Params for the runner
-const LOAD_SIZE = parseInt(__ENV.LOAD_SIZE || '100');
-const LEVELS = parseInt(__ENV.LEVELS || '10');
+const LOAD_SIZE = parseInt(__ENV.LOAD_SIZE || '500');
+const LEVELS = parseInt(__ENV.LEVELS || '2');
 const PLATEAU_DURATION = parseInt(__ENV.PLATEAU_DURATION || '300');
+const STATEFUL = __ENV.STATEFUL === 'true';
 
 // Params for the agent
 const DATA_SIZE = parseInt(__ENV.DATA_SIZE || '1000');
@@ -33,7 +34,7 @@ for (let i = 1; i <= LEVELS; i++) {
   stages.push({ duration: '60s', target: LOAD_SIZE * i });
 }
 stages.push({ duration: `${PLATEAU_DURATION}s`, target: LOAD_SIZE * LEVELS});
-stages.push({ duration: '30s', target: 0 }); // Ramp down
+stages.push({ duration: '60s', target: 0 }); // Ramp down
 
 // Test configuration
 export let options = {
@@ -46,9 +47,10 @@ export let options = {
     },
   },
   thresholds: {
-    'run_duration': ['p(95)<30000'],  // 95% of runs should complete within 30s
-    'successful_runs': ['count>100'],  // At least 100 successful runs
-    'http_req_failed': ['rate<0.2'],   // Error rate should be less than 20%
+    // These are the first set of goals I'd like to hit. To get the job just working and ramp on main, leaving them off for now.
+    // 'run_duration': ['p(95)<10000'],  // 95% of runs should complete within 10s
+    // 'successful_runs': ['count>100000'],  // At least 100,000 successful runs
+    // 'http_req_failed': ['rate<0.05'],   // Error rate should be less than 5%
   },
 };
 
@@ -75,10 +77,21 @@ export default function() {
         config: {
           recursion_limit: EXPAND + 2,
         },
+    });
+
+    // If the request is stateful, create a thread first and use it in the url
+    let url = `${BASE_URL}/runs/wait`;
+    if (STATEFUL) {
+      const thread = http.post(`${BASE_URL}/threads`, payload, {
+        headers,
+        timeout: '120s'  // k6 request timeout slightly longer than the server timeout
       });
+      const threadId = thread.json().thread_id;
+      url = `${BASE_URL}/threads/${threadId}/runs/wait`;
+    }
 
     // Make a single request to the wait endpoint
-    const response = http.post(`${BASE_URL}/runs/wait`, payload, {
+    const response = http.post(url, payload, {
       headers,
       timeout: '120s'  // k6 request timeout slightly longer than the server timeout
     });
@@ -141,9 +154,10 @@ export default function() {
 export function setup() {
   console.log(`Starting ramp benchmark`);
   console.log(`Running on pod: ${__ENV.POD_NAME || 'local'}`);
-  console.log(`Running ${LEVELS} levels with base size ${LOAD_SIZE}`);
+  console.log(`Running with the following ramp config: load size ${LOAD_SIZE}, levels ${LEVELS}, plateau duration ${PLATEAU_DURATION}, stateful ${STATEFUL}`);
+  console.log(`Running with the following agent config: data size ${DATA_SIZE}, delay ${DELAY}, expand ${EXPAND}, mode ${MODE}`);
 
-  return { startTime: new Date().toISOString() };
+  return { startTime: new Date().toISOString().replace(/:/g, '-').replace(/\..+/, '') };
 }
 
 // Handle summary
@@ -152,13 +166,14 @@ export function handleSummary(data) {
 
   // Create summary information with aggregated metrics
   const summary = {
-    timestamp: timestamp,
+    startTimestamp: data.setup_data.startTime,
+    endTimestamp: timestamp,
     metrics: {
-      totalRuns: data.metrics.successful_runs.values.count + data.metrics.failed_runs.values.count,
+      totalRuns: data.metrics.successful_runs.values.count + (data.metrics.failed_runs?.values?.count || 0),
       successfulRuns: data.metrics.successful_runs.values.count,
-      failedRuns: data.metrics.failed_runs.values.count,
+      failedRuns: data.metrics.failed_runs?.values?.count || 0,
       successRate: data.metrics.successful_runs.values.count /
-                  (data.metrics.successful_runs.values.count + data.metrics.failed_runs.values.count) * 100,
+                  (data.metrics.successful_runs.values.count + (data.metrics.failed_runs?.values?.count || 0)) * 100,
       averageDuration: data.metrics.run_duration.values.avg / 1000,  // in seconds
       p95Duration: data.metrics.run_duration.values["p(95)"] / 1000, // in seconds
       errors: {

langgraph_api-0.2.132/langgraph_api/__init__.py

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

{langgraph_api-0.2.129 → langgraph_api-0.2.132}/langgraph_api/api/assistants.py

@@ -61,7 +61,8 @@ def _get_configurable_jsonschema(graph: Pregel) -> dict:
     in favor of graph.get_context_jsonschema().
     """
     # Otherwise, use the config_schema method.
-    config_schema = graph.config_schema()
+    # TODO: Remove this when we no longer support langgraph < 0.6
+    config_schema = graph.config_schema()  # type: ignore[deprecated]
     model_fields = getattr(config_schema, "model_fields", None) or getattr(
         config_schema, "__fields__", None
     )
@@ -87,11 +88,11 @@ def _state_jsonschema(graph: Pregel) -> dict | None:
     for k in graph.stream_channels_list:
         v = graph.channels[k]
         try:
-            create_model(k, __root__=(v.UpdateType, None)).schema()
+            create_model(k, __root__=(v.UpdateType, None)).model_json_schema()
             fields[k] = (v.UpdateType, None)
         except Exception:
             fields[k] = (Any, None)
-    return create_model(graph.get_name("State"), **fields).schema()
+    return create_model(graph.get_name("State"), **fields).model_json_schema()
 
 
 def _graph_schemas(graph: Pregel) -> dict:
@@ -132,7 +133,7 @@ def _graph_schemas(graph: Pregel) -> dict:
             logger.warning(
                 f"Failed to get context schema for graph {graph.name} with error: `{str(e)}`"
             )
-            context_schema = graph.config_schema()
+            context_schema = graph.config_schema()  # type: ignore[deprecated]
     else:
         context_schema = None
 
@@ -366,7 +367,7 @@ async def patch_assistant(
 
 
 @retry_db
-async def delete_assistant(request: ApiRequest) -> ApiResponse:
+async def delete_assistant(request: ApiRequest) -> Response:
     """Delete an assistant by ID."""
     assistant_id = request.path_params["assistant_id"]
     validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")

{langgraph_api-0.2.129 → langgraph_api-0.2.132}/langgraph_api/api/meta.py

@@ -1,3 +1,5 @@
+from typing import cast
+
 import langgraph.version
 from starlette.responses import JSONResponse, PlainTextResponse
 
@@ -43,7 +45,7 @@ async def meta_metrics(request: ApiRequest):
 
     # collect stats
     metrics = get_metrics()
-    worker_metrics = metrics["workers"]
+    worker_metrics = cast(dict[str, int], metrics["workers"])
     workers_max = worker_metrics["max"]
     workers_active = worker_metrics["active"]
     workers_available = worker_metrics["available"]

{langgraph_api-0.2.129 → langgraph_api-0.2.132}/langgraph_api/api/openapi.py

@@ -25,7 +25,7 @@ def set_custom_spec(spec: dict):
 
 
 @lru_cache(maxsize=1)
-def get_openapi_spec() -> str:
+def get_openapi_spec() -> bytes:
     # patch the graph_id enums
     graph_ids = list(GRAPHS.keys())
     for schema in (

{langgraph_api-0.2.129 → langgraph_api-0.2.132}/langgraph_api/api/runs.py

@@ -1,9 +1,8 @@
 import asyncio
 from collections.abc import AsyncIterator
-from typing import Literal
+from typing import Literal, cast
 
 import orjson
-from langgraph.checkpoint.base.id import uuid6
 from starlette.exceptions import HTTPException
 from starlette.responses import Response, StreamingResponse
 
@@ -12,7 +11,7 @@ from langgraph_api.asyncio import ValueEvent, aclosing
 from langgraph_api.models.run import create_valid_run
 from langgraph_api.route import ApiRequest, ApiResponse, ApiRoute
 from langgraph_api.sse import EventSourceResponse
-from langgraph_api.utils import fetchone, get_pagination_headers, validate_uuid
+from langgraph_api.utils import fetchone, get_pagination_headers, uuid7, validate_uuid
 from langgraph_api.validation import (
     CronCreate,
     CronSearch,
@@ -92,7 +91,7 @@ async def stream_run(
     thread_id = request.path_params["thread_id"]
     payload = await request.json(RunCreateStateful)
     on_disconnect = payload.get("on_disconnect", "continue")
-    run_id = uuid6()
+    run_id = uuid7()
     sub = asyncio.create_task(Runs.Stream.subscribe(run_id))
 
     try:
@@ -132,7 +131,7 @@ async def stream_run_stateless(
     """Create a stateless run."""
     payload = await request.json(RunCreateStateless)
     on_disconnect = payload.get("on_disconnect", "continue")
-    run_id = uuid6()
+    run_id = uuid7()
     sub = asyncio.create_task(Runs.Stream.subscribe(run_id))
 
     try:
@@ -173,7 +172,7 @@ async def wait_run(request: ApiRequest):
     thread_id = request.path_params["thread_id"]
     payload = await request.json(RunCreateStateful)
     on_disconnect = payload.get("on_disconnect", "continue")
-    run_id = uuid6()
+    run_id = uuid7()
     sub = asyncio.create_task(Runs.Stream.subscribe(run_id))
 
     try:
@@ -255,7 +254,7 @@ 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()
+    run_id = uuid7()
     sub = asyncio.create_task(Runs.Stream.subscribe(run_id))
 
     try:
@@ -425,7 +424,10 @@ async def cancel_run(
     wait_str = request.query_params.get("wait", "false")
     wait = wait_str.lower() in {"true", "yes", "1"}
     action_str = request.query_params.get("action", "interrupt")
-    action = action_str if action_str in {"interrupt", "rollback"} else "interrupt"
+    action = cast(
+        Literal["interrupt", "rollback"],
+        action_str if action_str in {"interrupt", "rollback"} else "interrupt",
+    )
 
     async with connect() as conn:
         await Runs.cancel(
@@ -471,8 +473,9 @@ async def cancel_runs(
         for rid in run_ids:
             validate_uuid(rid, "Invalid run ID: must be a UUID")
     action_str = request.query_params.get("action", "interrupt")
-    action: Literal["interrupt", "rollback"] = (
-        action_str if action_str in ("interrupt", "rollback") else "interrupt"
+    action = cast(
+        Literal["interrupt", "rollback"],
+        action_str if action_str in ("interrupt", "rollback") else "interrupt",
     )
 
     async with connect() as conn:

{langgraph_api-0.2.129 → langgraph_api-0.2.132}/langgraph_api/api/ui.py

@@ -56,6 +56,8 @@ async def handle_ui(request: ApiRequest) -> Response:
 
         # Use http:// protocol if accessing a localhost service
         def is_host(needle: str) -> bool:
+            if not isinstance(host, str):
+                return False
             return host.startswith(needle + ":") or host == needle
 
         protocol = "http:" if is_host("localhost") or is_host("127.0.0.1") else ""

{langgraph_api-0.2.129 → langgraph_api-0.2.132}/langgraph_api/asgi_transport.py

@@ -13,7 +13,7 @@ from httpx import AsyncByteStream, Request, Response
 if typing.TYPE_CHECKING:  # pragma: no cover
     import asyncio
 
-    import trio
+    import trio  # type: ignore[unresolved-import]
 
     Event = asyncio.Event | trio.Event
 
@@ -37,7 +37,7 @@ def is_running_trio() -> bool:
 
 def create_event() -> Event:
     if is_running_trio():
-        import trio
+        import trio  # type: ignore[unresolved-import]
 
         return trio.Event()
 

{langgraph_api-0.2.129 → langgraph_api-0.2.132}/langgraph_api/asyncio.py

@@ -119,7 +119,7 @@ def create_task(
 
 def run_coroutine_threadsafe(
     coro: Coroutine[Any, Any, T], ignore_exceptions: tuple[type[Exception], ...] = ()
-) -> concurrent.futures.Future[T | None]:
+) -> concurrent.futures.Future[T] | concurrent.futures.Future[None]:
     if _MAIN_LOOP is None:
         raise RuntimeError("No event loop set")
     future = asyncio.run_coroutine_threadsafe(coro, _MAIN_LOOP)
@@ -226,7 +226,7 @@ def to_aiter(*args: T) -> AsyncIterator[T]:
 V = TypeVar("V")
 
 
-class aclosing(Generic[V], AbstractAsyncContextManager):
+class aclosing(Generic[V], AbstractAsyncContextManager[V]):
     """Async context manager for safely finalizing an asynchronously cleaned-up
     resource such as an async generator, calling its ``aclose()`` method.
 
@@ -255,14 +255,16 @@ class aclosing(Generic[V], AbstractAsyncContextManager):
         await self.thing.aclose()
 
 
-async def aclosing_aiter(aiter: AsyncIterator[T]) -> AsyncIterator[T]:
-    if hasattr(aiter, "__aenter__"):
-        async with aiter:
-            async for item in aiter:
+async def aclosing_aiter(
+    aiterator: AsyncIterator[T],
+) -> AsyncIterator[T]:
+    if hasattr(aiterator, "__aenter__"):
+        async with aiterator:  # type: ignore[invalid-context-manager]
+            async for item in aiterator:
                 yield item
     else:
-        async with aclosing(aiter):
-            async for item in aiter:
+        async with aclosing(aiterator):
+            async for item in aiterator:
                 yield item