langgraph-api 0.16.0.dev9__tar.gz → 0.16.0.dev10__tar.gz

{langgraph_api-0.16.0.dev9 → langgraph_api-0.16.0.dev10}/Makefile

@@ -313,6 +313,10 @@ VERSION_KIND ?= patch
 bump-version:
 	uv run --with hatch hatch version $(VERSION_KIND)
 
+sync-runtime-inmem-dep:
+	@python3 -c 'import pathlib,re; v=pathlib.Path("../runtime_inmem/langgraph_runtime_inmem/__init__.py").read_text(); m=re.search(r"__version__\s*=\s*\"(\d+)\.(\d+)", v); major,minor=map(int,m.groups()); p=pathlib.Path("pyproject.toml"); text,n=re.subn(r"\"langgraph-runtime-inmem>=[^\"]+\",", f"\"langgraph-runtime-inmem>={major}.{minor}.0.dev0,<{major}.{minor + 1}.0.dev0\",", p.read_text(), count=1); \
+	assert n==1, "langgraph-runtime-inmem dep not found in pyproject.toml"; p.write_text(text)'
+
 # A2A TCK (Test Compatibility Kit) targets
 # Requires a running server: make start (in another terminal)
 

{langgraph_api-0.16.0.dev9 → langgraph_api-0.16.0.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.16.0.dev9
+Version: 0.16.0.dev10
 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

{langgraph_api-0.16.0.dev9 → langgraph_api-0.16.0.dev10}/benchmark/README.md

@@ -129,7 +129,7 @@ by replaying them. That moves cost from write to read, and the read cost grows w
 thread depth. `delta_turns` measures it: one thread per VU, one turn per iteration,
 `turn_duration` tagged by depth bucket.
 
-`benchmark-delta.yml` runs four cells nightly, 20 users for 25 minutes each: plain channel, then
+`benchmark-delta.yml` runs four cells nightly, 20 users for 25 minutes each, 1 KB appended per turn (`CHECKPOINT_SIZE`): plain channel, then
 delta snapshotting every 50 (`benchmark_delta_freq`, the deepagents setting), 500
 (`benchmark_delta_500`) and 1000 (`benchmark_delta`, the library default). `delta-report.js` posts
 a headline table (non-delta vs delta at 50: read, write, storage by depth) and one table per metric

{langgraph_api-0.16.0.dev9 → langgraph_api-0.16.0.dev10}/benchmark/benchmark-runners/delta_turns.ts

@@ -52,6 +52,8 @@ interface DeltaTurnsData {
   plan: TurnPlan;
   guardFailure: string | null;
   drift: string | null;
+  /** Non-200 status of the cold state read, which is a failed request, not a correctness failure. */
+  stateStatus: number | null;
 }
 
 export class DeltaTurns extends BenchmarkRunner {
@@ -96,19 +98,24 @@ export class DeltaTurns extends BenchmarkRunner {
 
     let guardFailure: string | null = null;
     let drift: string | null = null;
+    let stateStatus: number | null = null;
     // A failed body is not state, and comparing against it would report drift
     // on top of the failure that caused it.
     if (response.status === 200 && (plan.guard || plan.verify)) {
-      const readStartedAt = Date.now();
       const state = http.get(`${baseUrl}/threads/${threadId}/state`, requestParams);
-      // The turn-2 guard read is at depth 2, not the bucket's end; timing it
-      // would pull the first row's read median down.
+      // Time to first byte: the server cannot start answering before it has
+      // rebuilt the value, and the body that follows is the whole state, which
+      // at depth is hundreds of KB the turn itself never sends. Wall time made
+      // a plain-channel read cost as much as a whole turn. The turn-2 guard
+      // read is at depth 2, not the bucket's end, so it is not timed.
       if (state.status === 200 && plan.verify) {
-        stateReadDuration.add(Date.now() - readStartedAt, { depth: plan.depthBucket });
+        stateReadDuration.add(state.timings.waiting, { depth: plan.depthBucket });
       }
       addResponse(responses, 'state', state);
       const body = state.status === 200 ? safeJson(state.body) : null;
-      if (body === null) {
+      if (state.status !== 200) {
+        stateStatus = state.status;
+      } else if (body === null) {
         guardFailure = plan.guard ? 'state_unreadable' : guardFailure;
         drift = plan.verify ? 'state_unreadable' : drift;
       } else {
@@ -135,7 +142,7 @@ export class DeltaTurns extends BenchmarkRunner {
       }
     }
 
-    return okResult(responses, { rawResponse: response, plan, guardFailure, drift });
+    return okResult(responses, { rawResponse: response, plan, guardFailure, drift, stateStatus });
   }
 
   static validate(
@@ -154,6 +161,7 @@ export class DeltaTurns extends BenchmarkRunner {
         'Response does not contain __error__': () => json?.__error__ === undefined,
         'Run advanced the thread by one turn': () =>
           json == null || plan == null || json.counter === plan.steps,
+        'Cold state read succeeded': () => result.data?.stateStatus == null,
         'Delta storage is as expected': () => result.data?.guardFailure == null,
         'Cold re-read matches the run': () => result.data?.drift == null,
       });
@@ -165,6 +173,7 @@ export class DeltaTurns extends BenchmarkRunner {
       const detail = [
         plan ? `turn=${plan.steps} graph=${plan.graphId}` : '',
         res ? `status=${res.status}` : '',
+        result.data?.stateStatus ? `state_status=${result.data.stateStatus}` : '',
         result.data?.guardFailure ? `guard=${result.data.guardFailure}` : '',
         result.data?.drift ? `drift=${result.data.drift}` : '',
       ]
@@ -173,7 +182,9 @@ export class DeltaTurns extends BenchmarkRunner {
       logFailure(DeltaTurns.toString(), result, { extra: detail });
       recordError(
         classifyError({
-          response: res ?? result.responses?.create_thread ?? null,
+          response: result.data?.stateStatus
+            ? result.responses?.state ?? null
+            : res ?? result.responses?.create_thread ?? null,
           hasApiError: json?.__error__ !== undefined,
           missingMessage: result.data?.drift != null || result.data?.guardFailure != null,
         }),

{langgraph_api-0.16.0.dev9 → langgraph_api-0.16.0.dev10}/benchmark/delta-report.js

@@ -183,7 +183,7 @@ export async function collectCells(resultsDir) {
       ...spec,
       stepOutcome: context.stepOutcome ?? (dir ? 'unknown' : 'missing'),
       summary: dir ? readSummary(findLatestSummary(dir)) : null,
-      load: { loadSize: context.loadSize, plateauDuration: context.plateauDuration },
+      load: { loadSize: context.loadSize, plateauDuration: context.plateauDuration, checkpointSize: context.checkpointSize },
       buckets: raw ? aggregateSamples(await readSamples(raw)) : {},
     });
   }
@@ -232,6 +232,39 @@ function deepest(buckets) {
   return depths.length ? depths.sort(byDepth).at(-1) : null;
 }
 
+/**
+ * A bucket counts as measured when it has a cold read: the row is about read
+ * and write. A run that stops mid-bucket has turns there but no read yet, and a
+ * verify turn whose state read failed can leave storage bytes with no read.
+ */
+function hasRead(bucket) {
+  return isNumber(bucket?.readP50Ms);
+}
+
+function measuredDeepest(buckets) {
+  const depths = Object.keys(buckets).filter((d) => hasRead(buckets[d]));
+  return depths.length ? depths.sort(byDepth).at(-1) : null;
+}
+
+/**
+ * Rows every cell in a table has a read for, checked per row: a slower cell
+ * stops earlier, and a verify turn whose state read failed leaves a hole at
+ * any depth. A row where one column is `-` compares nothing; how far each cell
+ * got is reported as its own line instead.
+ */
+function sharedDepths(cells, depths) {
+  return [...depths].filter((d) => cells.every((c) => hasRead(c.buckets?.[d]))).sort(byDepth);
+}
+
+function depthLine(cells, plateauDuration) {
+  const held = heldFor(plateauDuration) ?? 'the run';
+  const parts = cells.map((c) => {
+    const top = measuredDeepest(c.buckets ?? {});
+    return `${cellName(c)} ${top ? count(bucketEnd(top)) : '-'}`;
+  });
+  return `_Last measured turn in ${held}: ${parts.join(' · ')}_`;
+}
+
 function failureReason(cell) {
   const metrics = cell.summary?.metrics;
   if (!metrics) return `no results produced, step finished as \`${cell.stepOutcome}\``;
@@ -293,8 +326,10 @@ export function describeDelta(cells) {
   const users = withLoad ? `${count(Number(withLoad.load.loadSize))} users` : 'a few users';
   const held = heldFor(withLoad?.load?.plateauDuration);
   const load = [users, 'one thread each', held ? `${held} hold` : null, 'closed model'].filter(Boolean).join(', ');
+  const bytes = Number(withLoad?.load?.checkpointSize);
+  const appended = bytes >= 1024 ? `${Math.round(bytes / 1024)} KB` : bytes > 0 ? `${bytes} B` : null;
   return (
-    `k6: ${load}. Paths: one turn per iteration on a growing thread (run and wait), plus a cold state read and a storage read every 50 turns. ` +
+    `k6: ${load}. Paths: one turn per iteration on a growing thread (run and wait${appended ? `, ${appended} appended` : ''}), plus a cold state read and a storage read every 50 turns. ` +
     'Cells: plain channel vs DeltaChannel with a snapshot every 50 (deepagents), 500 and 1000 (library default). ' +
     "Measures read, write and checkpoint bytes by thread depth. Same load nightly on the day's revision, so a change is the server."
   );
@@ -308,10 +343,8 @@ export function headlineTable(cells, changesByCell) {
   const pair = HEADLINE.map((key) => cells.find((c) => c.cell === key)).filter(Boolean);
   const flaggedDepths = pair.flatMap((c) => (changesByCell.get(c) ?? []).filter((ch) => ch.flagged).map((ch) => ch.depth));
   // The deepest bucket often has turns but no cold read yet; a row of dashes says nothing.
-  const measured = new Set(
-    pair.flatMap((c) => Object.keys(c.buckets ?? {}).filter((d) => METRICS.some(([key]) => isNumber(c.buckets[d][key]))))
-  );
-  const depths = headlineRows(measured, flaggedDepths);
+  const measured = new Set(pair.flatMap((c) => Object.keys(c.buckets ?? {}).filter((d) => hasRead(c.buckets[d]))));
+  const depths = headlineRows(sharedDepths(pair, measured), flaggedDepths);
   if (depths.length === 0) return ['*No per-depth samples were recorded.*'];
   const w = 8;
   const units = { read: 'read s', write: 'write s', KB: 'KB' };
@@ -338,7 +371,7 @@ export function headlineTable(cells, changesByCell) {
 
 export function sweepTables(cells) {
   const deltas = cells.filter((c) => c.cell !== 'control');
-  const depths = sweepRows(new Set(deltas.flatMap((c) => Object.keys(c.buckets ?? {}))), deltas.map((c) => c.snapshot));
+  const depths = sweepRows(sharedDepths(deltas, new Set(deltas.flatMap((c) => Object.keys(c.buckets ?? {})))), deltas.map((c) => c.snapshot));
   if (depths.length === 0) return [];
   const w = 10;
   const titles = { read: 'read, median seconds', write: 'write, seconds', KB: 'storage, KB at that turn' };
@@ -430,6 +463,7 @@ export function buildReport(cells, context = {}) {
     `*Plain channel vs DeltaChannel at the deepagents setting* · a row every ${HEADLINE_EVERY} turns of a thread, plus the first and deepest; read and write are medians of the 50 turns before it, KB at that turn. Delta should keep both flat as the thread deepens.`
   );
   lines.push(...headlineTable(cells, changesByCell));
+  lines.push(depthLine(cells, cells.find((c) => c.load?.plateauDuration)?.load.plateauDuration));
   if (!anyBytes(cells)) {
     lines.push('_KB reads `-`: the deployment runs an API without `GET /threads/{id}/storage` yet._');
   }
@@ -488,13 +522,13 @@ function howToRead(cells) {
     `• *Tests:* ${cells.map((c) => `${cellName(c)} = ${c.label}`).join(' · ')}. Each is one k6 run of the same graph logic; only the channel type and snapshot frequency differ.`,
     withLoad ? `• *Load:* ${count(Number(withLoad.load.loadSize))} users, one thread each${held ? `, held ${held}` : ''}, one turn per iteration, no ramp.` : null,
     '• *Turn:* one `POST /runs/wait` on the thread, which reads the last checkpoint, runs one step and saves a new one. The row label is the thread depth the cold read was taken at.',
-    '• *Read:* a cold `GET /threads/{id}/state` every 50 turns. The server rebuilds the value from storage with nothing to write. With delta that is the replay of every diff since the last snapshot.',
+    '• *Read:* a cold `GET /threads/{id}/state` every 50 turns, timed to the server\'s first byte, so sending the state back is not counted. The server rebuilds the value from storage with nothing to write. With delta that is the replay of every diff since the last snapshot.',
     '• *Write:* the turn\'s median latency minus the cold read, so what saving one more checkpoint costs. It still includes the fixed cost of queueing and running the one-node step, identical in every cell, so compare columns; it is not a checkpoint-write latency on its own.',
     '• *Storage:* `GET /threads/{id}/storage` every 50 turns, the bytes the thread occupies at that turn.',
     `• *Regressed / Improved:* read, write or storage at the deepest turn every night reached, outside its own usual range over the last ${MIN_HISTORY_NIGHTS}+ nights.`,
     `• *Errors:* failed requests by HTTP status. ${ERROR_ATTENTION} or more turn the dot yellow even when the cell passes.`,
     '• *Correctness check:* at turn 2 each cell confirms delta is on (delta cells) or off (plain cell), because a too-old langgraph silently degrades a DeltaChannel to a plain one. Every 50 turns the cold re-read is compared to what the run returned. A failure of either is a bug, not a slow night.',
-    '• *Rows:* the channel table shows a row every 250 turns plus the first and deepest; the sweep shows the turn before and at each snapshot. Every 50-turn row is in the run artifacts.',
+    '• *Rows:* the channel table shows a row every 250 turns plus the first and deepest; the sweep shows the turn before and at each snapshot. Tables stop at the depth every cell reached; the line under the channel table says how far each got. Every 50-turn row is in the run artifacts.',
     '• `-` in a cell: no number, the cell produced no results or no thread reached that depth.',
   ]
     .filter(Boolean)

{langgraph_api-0.16.0.dev9 → langgraph_api-0.16.0.dev10}/benchmark/delta-report.test.js

@@ -146,6 +146,25 @@ test('a night that stops mid-bucket compares at the last turn with a cold read,
   assert.match(text, /^100\s+.*0\.11▼/m);
 });
 
+test('tables stop where the slowest cell stopped, and the depth each cell reached is its own line', () => {
+  const tonight = night();
+  tonight[0].buckets['101-150'] = bucket(50, 400, 122880);
+  tonight[0].buckets['151-200'] = bucket(50, 400, 163840);
+  // delta/50 got nine turns into the next bucket, with no cold read there yet.
+  tonight[1].buckets['101-150'] = { turns: 9, p50Ms: 450, p95Ms: 600, readP50Ms: null, saveEstMs: null, bytes: null };
+  // delta/500's one thread there had its state read fail; only the storage probe answered.
+  tonight[2].buckets['101-150'] = { turns: 1, p50Ms: 450, p95Ms: 450, readP50Ms: null, saveEstMs: null, bytes: 1024 };
+  // delta/1000's first verify turn had its state read fail, with storage answering: a hole, not the end.
+  tonight[3].buckets['1-50'] = { turns: 500, p50Ms: 450, p95Ms: 600, readP50Ms: null, saveEstMs: null, bytes: 4096 };
+  const { text, thread } = buildReport(tonight, base);
+  assert.match(text, /^50\s+/m);
+  assert.match(text, /^100\s+/m);
+  assert.doesNotMatch(text, /^(150|200)\s+/m);
+  assert.match(text, /^_Last measured turn in 25 min: non-delta 200 · delta\/50 100 · delta\/500 100 · delta\/1000 100_$/m);
+  assert.doesNotMatch(thread[0], /^(50|150|200)\s+/m);
+  assert.match(thread[0], /^100\s+/m);
+});
+
 test('a deepest bucket with turns but no cold read yet is not a row of dashes', () => {
   const tonight = night();
   for (const c of tonight) c.buckets['101-150'] = { turns: 9, p50Ms: 450, p95Ms: 600, readP50Ms: null, saveEstMs: null, bytes: null };

langgraph_api-0.16.0.dev10/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.16.0.dev10"

{langgraph_api-0.16.0.dev9 → langgraph_api-0.16.0.dev10}/langgraph_api/stream.py

@@ -717,14 +717,16 @@ async def _consume_inline(
         except Exception as e:
             if isinstance(e, ExceptionGroup):
                 e = e.exceptions[0]
-            with suppress(Exception):
-                await Runs.Stream.publish(
-                    run_id,
-                    "error",
-                    await run_in_executor(None, json_dumpb, e),
-                    thread_id=thread_id,
-                )
             if isinstance(e, StreamPublishException):
+                # We swallow this and report the run as complete, so the worker
+                # never sees it and cannot surface it. Emit it to the client here.
+                with suppress(Exception):
+                    await Runs.Stream.publish(
+                        run_id,
+                        "error",
+                        await run_in_executor(None, json_dumpb, e),
+                        thread_id=thread_id,
+                    )
                 await logger.aerror(
                     "Suppressing stream consume exception",
                     run_id=str(run_id),
@@ -815,9 +817,6 @@ async def _consume_async_queue(
     except Exception as e:
         if isinstance(e, ExceptionGroup):
             e = e.exceptions[0]
-        with suppress(Exception):
-            error_payload = await run_in_executor(None, json_dumpb, e)
-            await _enqueue(("error", error_payload, "error", False))
         raise e
     finally:
         with suppress(Exception):

{langgraph_api-0.16.0.dev9 → langgraph_api-0.16.0.dev10}/langgraph_api/worker.py

@@ -1,6 +1,7 @@
 import asyncio
 import time
 import uuid
+from contextlib import suppress
 from datetime import UTC, datetime
 from typing import Any
 
@@ -33,6 +34,7 @@ from langgraph_api.metrics_otlp import (
     get_otlp_metrics_reporter,
 )
 from langgraph_api.schema import RUN_KWARGS_ENCRYPTION_SUBFIELDS, Run, StreamMode
+from langgraph_api.serde import json_dumpb
 from langgraph_api.stream import AnyStream, consume
 from langgraph_api.worker_runtime import (
     ALL_RETRIABLE_EXCEPTIONS,
@@ -360,6 +362,18 @@ async def worker(
                 if isinstance(exception, UserTimeout):
                     exception = exception.timeout_error
 
+                # Sole emitter of the terminal `error` stream event: consume()
+                # re-raises without emitting, so a retriable attempt stays silent
+                # until the run actually fails. Emit before the status write so raw
+                # SSE clients (no status fallback) see it even if that write fails.
+                with suppress(Exception):
+                    await Runs.Stream.publish(
+                        run_id,
+                        "error",
+                        json_dumpb(exception),
+                        thread_id=run["thread_id"],
+                    )
+
                 # We're outside the original `except` block, so build exc_info manually.
                 # This preserves traceback logging for non-remote exceptions.
                 exc_info = None

langgraph_api-0.16.0.dev9/langgraph_api/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.16.0.dev9"