langgraph-api 0.18.0.dev11__tar.gz → 0.18.0.dev13__tar.gz

{langgraph_api-0.18.0.dev11 → langgraph_api-0.18.0.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.18.0.dev11
+Version: 0.18.0.dev13
 Author-email: Will Fu-Hinthorn <will@langchain.dev>, Josh Rogers <josh@langchain.dev>, Parker Rule <parker@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE
@@ -13,7 +13,7 @@ Requires-Dist: grpcio-tools==1.81.1
 Requires-Dist: grpcio<1.82.0,>=1.81.0
 Requires-Dist: httptools>=0.5.0; platform_system != 'Windows'
 Requires-Dist: httpx>=0.25.0
-Requires-Dist: jsonschema-rs<0.45,>=0.20.0
+Requires-Dist: jsonschema-rs<0.45,>=0.23.0
 Requires-Dist: langchain-core>=0.3.64
 Requires-Dist: langchain-protocol<0.1,>=0.0.18
 Requires-Dist: langgraph-checkpoint<5,>=3.0.1

{langgraph_api-0.18.0.dev11 → langgraph_api-0.18.0.dev13}/benchmark/REPORTS.md

@@ -17,8 +17,8 @@ in the same channel is separate and not covered here.
   something to say, worst first.
 - **Regressed / Improved.** A figure is flagged only when it leaves its own
   usual range over the recent nights: the 9 latest on tonight's CPUs for the
-  daily reports, the 9 before tonight for delta, the 7 latest on tonight's CPUs
-  for capacity, where ▲ better and ▼ worse also mark the cell in the table. The usual range is half the spread
+  daily and delta reports, the 7 latest on tonight's CPUs for capacity, where
+  ▲ better and ▼ worse also mark the cell in the table. The usual range is half the spread
   between the best and worst of those nights, and never less than 10%, so a
   series that swings 40% night to night is not flagged for moving 15%.
   Flags start once five nights of history exist; until then the post says how
@@ -32,7 +32,10 @@ in the same channel is separate and not covered here.
   line says when a path or tier moved since the night before, and flags only
   compare nights on the same CPUs, so a night on a slower machine starts its
   own baseline instead of reading as a regression. A deployment with several
-  workers is compared by the set of CPUs they ran on; the thread gives the mix.
+  workers is labeled `mostly amd rome` when at least three in four ran on it,
+  and by every CPU it saw otherwise, so a night with one slow worker in ten is
+  not compared with a night with nine; the daily and delta threads give the
+  counts.
   Nights from before this check only compare with each other.
 - **The thread** holds the full numbers: per-run or per-cell detail and
   improvements with before and after values; the daily threads also give the
@@ -72,8 +75,8 @@ that run's threads, not a growing history.
 - `p95 s`: 95% of iterations finished within this many seconds tonight. When
   it left its usual range, the Regressed or Improved line says so, with the
   before and after.
-- `last 10`: p95 over the same 10 nights the flags use, oldest on the left,
-  tonight on the right. Taller is slower. Each row has its own scale, so a full
+- `last 10`: p95 over tonight and the 9 nights before it on any CPU, oldest on
+  the left, tonight on the right; the flags use only the nights on tonight's CPU. Taller is slower. Each row has its own scale, so a full
   bar means that runner's slowest night of the ten, not a number of seconds:
   compare a row with itself, not with the row below. The bars never stretch
   small noise to full height, so a real step stands out.

{langgraph_api-0.18.0.dev11 → langgraph_api-0.18.0.dev13}/benchmark/daily-report.js

@@ -235,13 +235,12 @@ function failureReason(run) {
   return `step finished as \`${run.stepOutcome}\``;
 }
 
-/** The flag baseline stays at a week; the older nights only draw the trend. */
-/** Nights in the table's trend, tonight included. The flags compare against the other nights, so both mean the same window. */
+/** Nights in the table's trend, tonight included. The flags compare with as many past nights, taken from those on tonight's CPU. */
 export const NIGHTS = 10;
 
 const baseline = (run) => (run.history ?? []).slice(0, NIGHTS - 1);
 
-// The trend draws every night; the flags compare only nights on tonight's kinds of CPU.
+// The trend draws every night; the flags compare only nights on tonight's CPU.
 const comparable = (run) => sameCpu(run.history ?? [], run.summary?.metrics?.serverCpus).slice(0, NIGHTS - 1);
 
 const cpuOf = (run) => cpuSignature(run.summary?.metrics?.serverCpus);

{langgraph_api-0.18.0.dev11 → langgraph_api-0.18.0.dev13}/benchmark/delta-report.js

@@ -10,7 +10,7 @@ import readline from 'node:readline';
 import { fileURLToPath } from 'node:url';
 
 import { ERROR_ATTENTION, MIN_SUCCESS_RATE, describeThreshold, errorParts, findLatestSummary, isHealthy, readApiVersion, readSummary } from './daily-report.js';
-import { MIN_HISTORY_NIGHTS, describeCpus, flaggedChange, formatMove, sparkline } from './history.js';
+import { MIN_HISTORY_NIGHTS, cpuSignature, describeCpus, flaggedChange, formatMove, sameCpu, sparkline } from './history.js';
 import { dotFor, footer, postReport } from './slack.js';
 
 const HERE = path.dirname(fileURLToPath(import.meta.url));
@@ -173,7 +173,16 @@ export async function collectRun(resultsDir) {
   };
 }
 
-/** Newest night first. */
+/** What a night saves as `delta_report.json` for the trend and flags of the nights after it. */
+export function nightRecord(run) {
+  return {
+    design: DESIGN,
+    serverCpus: run.summary?.metrics?.serverCpus ?? null,
+    cells: Object.fromEntries(run.cells.map((c) => [c.cell, { buckets: c.buckets }])),
+  };
+}
+
+/** Newest night first, each as `nightRecord` saved it. */
 export function loadDeltaHistory(dir) {
   let runs;
   try {
@@ -194,7 +203,7 @@ export function loadDeltaHistory(dir) {
     }
     const file = files.find((name) => path.basename(name) === 'delta_report.json');
     const report = file ? readSummary(path.join(dir, run, file)) : null;
-    if (report?.design === DESIGN && report.cells) nights.push(report.cells);
+    if (report?.design === DESIGN && report.cells) nights.push(report);
   }
   return nights;
 }
@@ -242,7 +251,7 @@ export function cellChanges(cell, depth, history) {
   const tonight = cell.buckets?.[depth];
   const changes = [];
   for (const [key, label, format, unit] of METRICS) {
-    const past = history.map((night) => night[cell.cell]?.buckets?.[depth]?.[key]).filter(isNumber);
+    const past = history.map((night) => night.cells[cell.cell]?.buckets?.[depth]?.[key]).filter(isNumber);
     const flagged = flaggedChange(tonight?.[key], past, { higherIsBetter: false });
     if (!flagged) continue;
     changes.push({ key, better: flagged.better, text: `${cell.label} ${label} ${formatMove(format(flagged.median), format(tonight[key]), flagged.deltaPct, unit)}` });
@@ -265,7 +274,7 @@ function mainTable(cells, depth, history) {
   const lines = ['```', `${''.padEnd(6)}${'base'.padStart(5)} delta last ${NIGHTS}`];
   for (const [key, label, format] of METRICS) {
     if (key === 'bytes' && !anyBytes(base)) continue;
-    const past = history.slice(0, NIGHTS - 1).reverse().map((night) => night[delta.cell]?.buckets?.[depth]?.[key]);
+    const past = history.slice(0, NIGHTS - 1).reverse().map((night) => night.cells[delta.cell]?.buckets?.[depth]?.[key]);
     const trend = sparkline([...past, delta.buckets[depth]?.[key]]);
     lines.push(`${label.padEnd(6)}${format(base.buckets[depth]?.[key]).padStart(5)}${format(delta.buckets[depth]?.[key]).padStart(5)} ${trend}`);
   }
@@ -305,7 +314,9 @@ export function buildReport(run, context = {}) {
   const depth = deepestComplete(run.cells, Number(run.load?.loadSize) || null);
   const target = Number(run.load?.turns) || null;
   const stoppedAt = target && (!depth || bucketEnd(depth) < target) ? (depth ? bucketEnd(depth) : 0) : null;
-  const changes = depth ? run.cells.flatMap((cell) => cellChanges(cell, depth, history)) : [];
+  // The trend draws every night; the flags compare only nights on tonight's CPU.
+  const comparable = sameCpu(history, metrics?.serverCpus).slice(0, NIGHTS - 1);
+  const changes = depth ? run.cells.flatMap((cell) => cellChanges(cell, depth, comparable)) : [];
   const regressed = changes.filter((c) => !c.better);
   const improved = changes.filter((c) => c.better);
 
@@ -321,7 +332,8 @@ export function buildReport(run, context = {}) {
 
   const dot = dotFor({ failed, attention: guard > 0 || httpCount >= ERROR_ATTENTION || stoppedAt !== null || regressed.length > 0 });
   const date = now.toLocaleDateString('en-US', { month: 'short', day: 'numeric', timeZone: 'UTC' });
-  const lines = [`${dot} *Delta Channel · ${date}*${manual ? ' · manual run' : ''}${apiVersion ? ` · API ${apiVersion}` : ''} · ${clauses.join(' · ')}`];
+  const cpu = cpuSignature(metrics?.serverCpus);
+  const lines = [`${dot} *Delta Channel · ${date}*${manual ? ' · manual run' : ''}${apiVersion ? ` · API ${apiVersion}` : ''}${cpu ? ` · ${cpu}` : ''} · ${clauses.join(' · ')}`];
   if (failed) lines.push(`*Failed:* ${failureReason(run)}`);
   if (guard > 0 || httpParts.length > 0) {
     lines.push(`*Errors:* ${[...httpParts, guard > 0 ? `correctness check failed × ${count(guard)}` : null].filter(Boolean).join(', ')}`);
@@ -335,7 +347,7 @@ export function buildReport(run, context = {}) {
   if (depth && !anyBytes(run.cells[0])) {
     lines.push('_No data row: the deployment runs an API without `GET /threads/{id}/storage` yet._');
   }
-  if (history.length < MIN_HISTORY_NIGHTS) lines.push(`_${history.length} of ${MIN_HISTORY_NIGHTS} nights of history, no change flags yet_`);
+  if (comparable.length < MIN_HISTORY_NIGHTS) lines.push(`_${comparable.length} of ${MIN_HISTORY_NIGHTS} nights of history${cpu ? ' on this cpu' : ''}, no change flags yet_`);
   lines.push(footer('delta-channel', artifactUrl));
 
   return { text: lines.join('\n'), thread: [threadText(run, metrics, guard, improved)] };
@@ -375,11 +387,7 @@ async function main() {
   const run = await collectRun(process.env.RESULTS_DIR || path.join(HERE, 'results'));
   const outDir = process.env.OUT_DIR || path.join(HERE, 'delta-report');
   mkdirSync(outDir, { recursive: true });
-  // Tonight's aggregate, for the trend and flags of the nights to come.
-  writeFileSync(
-    path.join(outDir, 'delta_report.json'),
-    JSON.stringify({ design: DESIGN, cells: Object.fromEntries(run.cells.map((c) => [c.cell, { buckets: c.buckets }])) }, null, 2)
-  );
+  writeFileSync(path.join(outDir, 'delta_report.json'), JSON.stringify(nightRecord(run), null, 2));
   const report = safeBuildReport(run, {
     apiVersion: process.env.API_VERSION || readApiVersion(),
     artifactUrl: process.env.ARTIFACT_URL,

{langgraph_api-0.18.0.dev11 → langgraph_api-0.18.0.dev13}/benchmark/delta-report.test.js

@@ -3,7 +3,7 @@ import assert from 'node:assert/strict';
 import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
-import { DESIGN, aggregateByCell, aggregateSamples, buildReport, collectRun, gain, growthTables, loadDeltaHistory } from './delta-report.js';
+import { DESIGN, aggregateByCell, aggregateSamples, buildReport, collectRun, gain, growthTables, loadDeltaHistory, nightRecord } from './delta-report.js';
 import { PHONE_WIDTH, footer, widestCodeLine } from './slack.js';
 
 const MB = 1024 * 1024;
@@ -66,11 +66,10 @@ function run({ base = {}, delta = {}, summary, stepOutcome = 'success' } = {}) {
   };
 }
 
-const nightFrom = (r) => Object.fromEntries(r.cells.map((c) => [c.cell, { buckets: c.buckets }]));
 const base = { apiVersion: '0.16.0rc2', now: new Date('2026-09-30T14:00:00Z'), artifactUrl: 'https://github.com/x/y/actions/runs/1' };
 
 test('a clean night is the verdict, one table at the last turn, and a footer', () => {
-  const history = Array.from({ length: 9 }, () => nightFrom(run()));
+  const history = Array.from({ length: 9 }, () => nightRecord(run()));
   const { text } = buildReport(run(), { ...base, history });
   assert.deepEqual(text.split('\n'), [
     '🟢 *Delta Channel · Sep 30* · API 0.16.0rc2 · all quiet',
@@ -106,7 +105,7 @@ test('the thread shows each metric as the threads grow, with the gain at every r
 });
 
 test('a delta metric outside its usual range is named above the table once five nights exist', () => {
-  const history = Array.from({ length: 5 }, () => nightFrom(run()));
+  const history = Array.from({ length: 5 }, () => nightRecord(run()));
   const { text, thread } = buildReport(run({ delta: { read: 130, save: 30 } }), { ...base, history });
   assert.match(text, /^🟡 .* · 1 regression$/m);
   assert.match(text, /^⚠️ \*delta read 0\.10 → 0\.13 s \(\+30%\)\*$/m);
@@ -115,12 +114,31 @@ test('a delta metric outside its usual range is named above the table once five
 });
 
 test('fewer than five nights compare nothing, and the post says so', () => {
-  const history = Array.from({ length: 4 }, () => nightFrom(run()));
+  const history = Array.from({ length: 4 }, () => nightRecord(run()));
   const { text } = buildReport(run({ delta: { read: 500 } }), { ...base, history });
   assert.doesNotMatch(text, /⚠️/);
   assert.match(text, /^_4 of 5 nights of history, no change flags yet_$/m);
 });
 
+test('a night is compared with the nine latest nights saved on its cpu', () => {
+  const rome = { 'AuthenticAMD 143/49': 10 };
+  const dir = mkdtempSync(path.join(tmpdir(), 'delta-cpu-'));
+  const save = (runId, night) => {
+    mkdirSync(path.join(dir, runId), { recursive: true });
+    writeFileSync(path.join(dir, runId, 'delta_report.json'), JSON.stringify(nightRecord(night)));
+  };
+  save('100', run({ delta: { read: 200 }, summary: { serverCpus: rome } }));
+  for (let runId = 101; runId <= 109; runId++) save(String(runId), run({ summary: { serverCpus: rome } }));
+  const history = loadDeltaHistory(dir);
+
+  const moved = buildReport(run({ delta: { read: 130 }, summary: { serverCpus: { 'AuthenticAMD 143/49': 2, 'GenuineIntel 6/79': 8 } } }), { ...base, history });
+  assert.match(moved.text, /^🟢 \*Delta Channel · Sep 30\* · API 0\.16\.0rc2 · mostly intel broadwell · all quiet$/m, 'against the rome nights this would be +30%');
+  assert.match(moved.text, /^_0 of 5 nights of history on this cpu, no change flags yet_$/m);
+
+  const stayed = buildReport(run({ delta: { read: 130 }, summary: { serverCpus: rome } }), { ...base, history });
+  assert.match(stayed.text, /^⚠️ \*delta read 0\.10 → 0\.13 s \(\+30%\)\*$/m, 'the 0.20 s read of the tenth night back is outside the baseline');
+});
+
 test('history keeps only nights measured with this design, newest first', () => {
   const dir = mkdtempSync(path.join(tmpdir(), 'delta-history-'));
   const write = (runId, report) => {
@@ -131,7 +149,7 @@ test('history keeps only nights measured with this design, newest first', () =>
   write('300', { design: DESIGN, cells: { control: { tag: 'newer' } } });
   write('200', { cells: { control: { tag: 'one job per cell' } } });
   write('250', { design: 'paired-messages', cells: { control: { tag: 'median write' } } });
-  assert.deepEqual(loadDeltaHistory(dir).map((night) => night.control.tag), ['newer', 'older']);
+  assert.deepEqual(loadDeltaHistory(dir).map((night) => night.cells.control.tag), ['newer', 'older']);
 });
 
 test('without storage readings the data row is left out and the post says why', () => {

{langgraph_api-0.18.0.dev11 → langgraph_api-0.18.0.dev13}/benchmark/history.js

@@ -170,31 +170,41 @@ function cpuName(key) {
   return CPU_NAMES[normalized] ?? normalized;
 }
 
+/** `[name, workers]` per kind of CPU, most workers first. */
 function cpuCounts(serverCpus) {
   const counts = {};
   for (const [key, workers] of Object.entries(serverCpus ?? {})) {
     const name = cpuName(key);
     counts[name] = (counts[name] ?? 0) + (isNumber(workers) ? workers : 0);
   }
-  return counts;
+  return Object.entries(counts).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
 }
 
-/** The kinds of CPU a night ran on, the key the reports compare nights by; null when unknown. */
+/**
+ * The key the reports compare nights by, null when unknown: "amd rome" when
+ * every worker ran on it, "mostly amd rome" when at least three in four did,
+ * every CPU seen otherwise. The share of slow workers moves a night's p95 and
+ * capacity, so one slow worker in ten and nine in ten are different machines;
+ * the wide middle keeps near-even mixes, the usual case on staging, on one baseline.
+ */
 export function cpuSignature(serverCpus) {
-  const names = Object.keys(cpuCounts(serverCpus)).sort();
-  return names.length > 0 ? names.join(" + ") : null;
+  const entries = cpuCounts(serverCpus);
+  if (entries.length < 2) return entries[0]?.[0] ?? null;
+  const workers = entries.reduce((sum, [, n]) => sum + n, 0);
+  const [top, most] = entries[0];
+  return most * 4 >= workers * 3 ? `mostly ${top}` : entries.map(([name]) => name).sort().join(" + ");
 }
 
 /** "amd rome" for one worker, "6 amd rome, 4 intel broadwell" for several. */
 export function describeCpus(serverCpus) {
-  const entries = Object.entries(cpuCounts(serverCpus)).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+  const entries = cpuCounts(serverCpus);
   if (entries.length === 0) return null;
   const workers = entries.reduce((sum, [, n]) => sum + n, 0);
   return workers === 1 ? entries[0][0] : entries.map(([name, n]) => `${n} ${name}`).join(", ");
 }
 
 /**
- * The nights that ran on tonight's kinds of CPU. A night without the probe only
+ * The nights with tonight's CPU label. A night without the probe only
  * matches a night without it, so reports keep their history until the probe
  * starts answering.
  */

{langgraph_api-0.18.0.dev11 → langgraph_api-0.18.0.dev13}/benchmark/history.test.js

@@ -149,9 +149,11 @@ test("cpus are named the same inside and outside gVisor, and unknown ones keep t
   assert.equal(cpuSignature({}), null);
 });
 
-test("a mix of cpus is one signature, and the description counts the workers", () => {
+test("several workers are mostly one cpu when three in four ran on it, and the description counts them", () => {
   const mixed = { "GenuineIntel 6/79": 4, "AuthenticAMD 143/49": 6 };
   assert.equal(cpuSignature(mixed), "amd rome + intel broadwell");
+  assert.equal(cpuSignature({ "GenuineIntel 6/79": 9, "AuthenticAMD 143/49": 1 }), "mostly intel broadwell");
+  assert.equal(cpuSignature({ "GenuineIntel 6/79": 2, "AuthenticAMD 143/49": 6 }), "mostly amd rome", "exactly three in four");
   assert.equal(describeCpus(mixed), "6 amd rome, 4 intel broadwell");
   assert.equal(describeCpus({ "AuthenticAMD 143/49": 1 }), "amd rome", "one worker needs no count");
   assert.equal(describeCpus(null), null);
@@ -165,6 +167,13 @@ test("only nights on the same cpus compare, and nights before the probe only com
   assert.deepEqual(sameCpu(nights, rome.serverCpus), [rome, rome]);
   assert.deepEqual(sameCpu(nights, broadwell.serverCpus), [broadwell]);
   assert.deepEqual(sameCpu(nights, null), [before]);
+
+  const mostlyRome = { serverCpus: { "AuthenticAMD 143/49": 8, "GenuineIntel 6/79": 2 } };
+  const even = { serverCpus: { "AuthenticAMD 143/49": 5, "GenuineIntel 6/79": 5 } };
+  const mostlyBroadwell = { serverCpus: { "AuthenticAMD 143/49": 1, "GenuineIntel 6/79": 9 } };
+  const split = [mostlyBroadwell, even, mostlyRome, rome];
+  assert.deepEqual(sameCpu(split, { "AuthenticAMD 143/49": 9, "GenuineIntel 6/79": 1 }), [mostlyRome], "one slow worker in ten compares with two, not with none, five or nine");
+  assert.deepEqual(sameCpu(split, { "AuthenticAMD 143/49": 4, "GenuineIntel 6/79": 6 }), [even], "six in ten compares with five");
 });
 
 test("sparkline keeps noise mid-height, draws a real step full height, and leaves gaps for missing nights", () => {

{langgraph_api-0.18.0.dev11 → langgraph_api-0.18.0.dev13}/constraints.txt

@@ -13,7 +13,7 @@ uvicorn>=0.29.0
 sse-starlette>=2.1.3,<4.0.0
 uvloop>=0.18.0
 httptools>=0.5.0
-jsonschema-rs>=0.20.0
+jsonschema-rs>=0.23.0
 structlog>=24.1.0
 cloudpickle>=3.0.0
 truststore>=0.1

langgraph_api-0.18.0.dev13/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.18.0.dev13"

{langgraph_api-0.18.0.dev11 → langgraph_api-0.18.0.dev13}/langgraph_api/api/__init__.py

@@ -28,10 +28,14 @@ from langgraph_api.api.threads import threads_routes
 from langgraph_api.api.ui import ui_routes
 from langgraph_api.auth.middleware import auth_middleware
 from langgraph_api.config import (
+    A2A_ENABLED,
     FF_PYSPY_PROFILING_ENABLED,
     HTTP_CONFIG,
     LANGGRAPH_ENCRYPTION,
+    MCP_ENABLED,
     MIGRATIONS_PATH,
+    RUNS_ENABLED,
+    THREADS_ENABLED,
 )
 from langgraph_api.feature_flags import (
     FF_V2_EVENT_STREAMING,
@@ -166,9 +170,9 @@ protected_routes: list[BaseRoute] = []
 if HTTP_CONFIG:
     if not HTTP_CONFIG.get("disable_assistants"):
         protected_routes.extend(assistants_routes)
-    if not HTTP_CONFIG.get("disable_runs"):
+    if RUNS_ENABLED:
         protected_routes.extend(runs_routes)
-    if not HTTP_CONFIG.get("disable_threads"):
+    if THREADS_ENABLED:
         protected_routes.extend(threads_routes)
     if not HTTP_CONFIG.get("disable_store"):
         protected_routes.extend(store_routes)
@@ -176,21 +180,16 @@ if HTTP_CONFIG:
         protected_routes.extend(profile_routes)
     if not HTTP_CONFIG.get("disable_ui"):
         protected_routes.extend(ui_routes)
-    if not HTTP_CONFIG.get("disable_mcp"):
+    if MCP_ENABLED:
         protected_routes.extend(mcp_routes)
-    if not HTTP_CONFIG.get("disable_a2a"):
+    if A2A_ENABLED:
         protected_routes.extend(a2a_routes)
-    # ``disable_runs`` also gates event streaming because the v2 transport
-    # exposes run-creating commands (``run.start`` / ``run.cancel`` /
-    # ``run.attach`` over the WS, plus the ``/runs/{run_id}/protocol``
-    # attach route). If an operator hardens a deployment with
-    # ``disable_runs=true``, leaving event streaming open would be a
-    # backdoor that lets clients create runs anyway. ``disable_event_streaming``
-    # is the narrow knob (turn off just v2); ``disable_runs`` is the broad
-    # knob (no run-related functionality at all).
+    # disable_runs also unmounts event streaming: its WebSocket and the
+    # /runs/{run_id}/protocol route can start, cancel and attach runs, so leaving
+    # them mounted would let clients create runs on a deployment that disabled runs.
     if (
         FF_V2_EVENT_STREAMING
-        and not HTTP_CONFIG.get("disable_runs")
+        and RUNS_ENABLED
         and not HTTP_CONFIG.get("disable_event_streaming")
     ):
         protected_routes.extend(event_streaming_routes)

{langgraph_api-0.18.0.dev11 → langgraph_api-0.18.0.dev13}/langgraph_api/api/event_streaming.py

@@ -330,7 +330,7 @@ async def _thread_events(request: Request) -> Response:
         finally:
             await manager.close()
 
-    return EventSourceResponse(body_iter())
+    return EventSourceResponse(body_iter(), on_close=manager.close)
 
 
 # ---------------------------------------------------------------------------

langgraph_api-0.18.0.dev13/langgraph_api/api/mcp/_call_thread.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+from contextlib import asynccontextmanager, contextmanager
+from dataclasses import dataclass
+from http import HTTPStatus
+from typing import TYPE_CHECKING
+
+import httpx
+import jsonschema_rs
+import mcp_types as types
+import structlog
+from mcp.shared.exceptions import MCPError
+from starlette.exceptions import HTTPException
+
+from langgraph_api.api.mcp._constants import (
+    BREAKPOINT_MESSAGE,
+    FINISHED_CALL_TTL_MINUTES,
+    PAUSED_CALL_TTL_MINUTES,
+)
+from langgraph_api.api.mcp._outcome import Failed, Paused, RunOutcome, parse_outcome
+from langgraph_api.api.mcp._request_state import Binding, InvalidRequestState
+from langgraph_api.config import THREAD_TTL
+from langgraph_api.models.run import create_valid_run
+from langgraph_api.validation import RunCreateStateful, sanitize_and_validate
+from langgraph_runtime.database import connect
+from langgraph_runtime.retry import retry_db
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator, Iterator, Mapping
+    from uuid import UUID
+
+    from langgraph_sdk.client import LangGraphClient
+    from langgraph_sdk.schema import Thread
+    from pydantic import JsonValue
+
+    from langgraph_api.api.mcp._calls import ToolCallParams
+    from langgraph_api.api.mcp._request_state import RequestState
+    from langgraph_api.schema import Interrupt
+
+logger = structlog.stdlib.get_logger(__name__)
+
+
+@dataclass(frozen=True, slots=True)
+class CallThread:
+    client: LangGraphClient
+    headers: Mapping[str, str]
+    assistant_id: str
+    thread_id: str
+
+    @classmethod
+    async def create(
+        cls, client: LangGraphClient, headers: Mapping[str, str], assistant_id: str
+    ) -> CallThread:
+        thread = await client.threads.create(
+            ttl=_within_operator_ttl(PAUSED_CALL_TTL_MINUTES), headers=headers
+        )
+        return cls(client, headers, assistant_id, thread["thread_id"])
+
+    async def get(self) -> Thread:
+        with _invalid_state_if_missing():
+            return await self.client.threads.get(self.thread_id, headers=self.headers)
+
+    async def pending(self, thread: Thread) -> list[Interrupt]:
+        if thread["status"] != "interrupted":
+            return []
+        with _invalid_state_if_missing():
+            state = await self.client.threads.get_state(
+                self.thread_id, headers=self.headers
+            )
+        return [
+            interrupt for task in state["tasks"] for interrupt in task["interrupts"]
+        ]
+
+    async def bind(self, binding: Binding, replacing: Binding | None) -> None:
+        if binding == replacing:
+            return
+        if replacing is not None and await self._bound() not in (replacing, binding):
+            return
+        await self.client.threads.update(
+            self.thread_id,
+            metadata=binding.metadata,
+            ttl=_within_operator_ttl(PAUSED_CALL_TTL_MINUTES),
+            headers=self.headers,
+        )
+
+    async def run(self, params: ToolCallParams) -> RunOutcome:
+        value = await self.client.runs.wait(
+            thread_id=self.thread_id,
+            assistant_id=self.assistant_id,
+            input=params.input,
+            context=params.context,
+            durability="exit",
+            headers=self.headers,
+            raise_error=False,
+        )
+        return await self._outcome(value)
+
+    async def resume(
+        self,
+        value: JsonValue,
+        state: RequestState,
+        context: Mapping[str, JsonValue] | None,
+    ) -> RunOutcome:
+        try:
+            await self._create_run(self._resume_payload(value, context), state.run_id)
+        except HTTPException as error:
+            if error.status_code == HTTPStatus.NOT_FOUND:
+                raise InvalidRequestState from None
+            if error.status_code != HTTPStatus.CONFLICT:
+                raise
+            return await self.join(state)
+        return await self._wait_for(state)
+
+    async def join(self, state: RequestState) -> RunOutcome:
+        if not await self.resumed_with(state):
+            raise InvalidRequestState
+        return await self._wait_for(state)
+
+    async def resumed_with(self, state: RequestState) -> bool:
+        try:
+            await self.client.runs.get(
+                self.thread_id, str(state.run_id), headers=self.headers
+            )
+        except httpx.HTTPStatusError as error:
+            if error.response.status_code != HTTPStatus.NOT_FOUND:
+                raise
+            return False
+        return True
+
+    async def delete(self) -> None:
+        async with self._best_effort("Could not delete a finished MCP call's thread"):
+            await self.client.threads.delete(self.thread_id, headers=self.headers)
+
+    async def expire_soon(self) -> None:
+        async with self._best_effort("Could not shorten a finished MCP call's TTL"):
+            await self.client.threads.update(
+                self.thread_id,
+                metadata={},
+                ttl=_within_operator_ttl(FINISHED_CALL_TTL_MINUTES),
+                headers=self.headers,
+            )
+
+    async def _bound(self) -> Binding | None:
+        return Binding.stored((await self.get())["metadata"])
+
+    @asynccontextmanager
+    async def _best_effort(self, failure: str) -> AsyncIterator[None]:
+        try:
+            yield
+        except httpx.HTTPStatusError as error:
+            if error.response.status_code != HTTPStatus.NOT_FOUND:
+                await logger.awarning(
+                    failure,
+                    thread_id=self.thread_id,
+                    status_code=error.response.status_code,
+                )
+
+    @retry_db
+    async def _create_run(self, payload: dict[str, JsonValue], run_id: UUID) -> None:
+        async with connect() as conn:
+            await create_valid_run(
+                conn, self.thread_id, payload, self.headers, run_id=run_id
+            )
+
+    async def _wait_for(self, state: RequestState) -> RunOutcome:
+        with _invalid_state_if_missing():
+            value = await self.client.runs.join(
+                self.thread_id, str(state.run_id), headers=self.headers
+            )
+        return await self._outcome(value)
+
+    async def _outcome(self, value: JsonValue) -> RunOutcome:
+        outcome = parse_outcome(value)
+        if isinstance(outcome, Failed):
+            return outcome
+        thread = await self.get()
+        match thread["status"]:
+            case "busy":
+                raise InvalidRequestState
+            case "interrupted":
+                return await self._paused_or_stopped(thread)
+            case _:
+                return outcome
+
+    async def _paused_or_stopped(self, thread: Thread) -> Paused | Failed:
+        if interrupts := await self.pending(thread):
+            return Paused(tuple(interrupts))
+        return Failed(BREAKPOINT_MESSAGE)
+
+    def _resume_payload(
+        self, value: JsonValue, context: Mapping[str, JsonValue] | None
+    ) -> dict[str, JsonValue]:
+        payload: dict[str, JsonValue] = {
+            "assistant_id": self.assistant_id,
+            "command": {"resume": value},
+            "multitask_strategy": "reject",
+            "durability": "exit",
+        }
+        if context is not None:
+            payload["context"] = dict(context)
+        try:
+            sanitize_and_validate(payload, RunCreateStateful)
+        except jsonschema_rs.ValidationError:
+            raise MCPError(types.INVALID_PARAMS, "Invalid tool call context") from None
+        return payload
+
+
+def _within_operator_ttl(minutes: float) -> float:
+    operator_ttl = THREAD_TTL.get("default_ttl") if THREAD_TTL else None
+    return minutes if operator_ttl is None else min(minutes, operator_ttl)
+
+
+@contextmanager
+def _invalid_state_if_missing() -> Iterator[None]:
+    try:
+        yield
+    except httpx.HTTPStatusError as error:
+        if error.response.status_code != HTTPStatus.NOT_FOUND:
+            raise
+        raise InvalidRequestState from None

langgraph_api-0.18.0.dev13/langgraph_api/api/mcp/_calls.py

@@ -0,0 +1,20 @@
+import mcp_types as types
+from pydantic import JsonValue
+
+from langgraph_api.api.mcp._digest import digest
+
+
+class ToolCallParams(types.CallToolRequestParams):
+    arguments: dict[str, JsonValue] | None = None
+    context: dict[str, JsonValue] | None = None
+
+    @property
+    def input(self) -> dict[str, JsonValue]:
+        return self.arguments or {}
+
+    @property
+    def answers(self) -> types.InputResponses:
+        return self.input_responses or {}
+
+    def digest(self, assistant_id: str) -> str:
+        return digest(assistant_id, self.name, self.input)