langgraph-api 0.7.94__tar.gz → 0.7.95__tar.gz

{langgraph_api-0.7.94 → langgraph_api-0.7.95}/Makefile

@@ -1,7 +1,7 @@
 .PHONY: build release lint format test test_watch start start-inmem start-inmem-license-oss start start-js-server build-go-server start-go-server stop-go-server check-version check-base-imports test-a2a-tck test-a2a-tck-mandatory start-test-a2a-tck start-test-a2a-tck-mandatory start-test-a2a-tck-watch test-mcp-conformance start-test-mcp-conformance list-mcp-scenarios
 
 # Environment variables
-LANGSERVE_GRAPHS_ALL = '{"agent": {"path": "./tests/graphs/agent.py:graph", "description": "agent"}, "assistant_id_runtime": "./tests/graphs/assistant_id_runtime.py:graph", "custom_lifespan": "./tests/graphs/my_router.py:graph", "single_node": "./tests/graphs/single_node.py:graph", "benchmark": "./tests/graphs/benchmark.py:graph", "config_graph": "./tests/graphs/config_graph.py:graph", "other": "./tests/graphs/other.py:make_graph", "weather": "./tests/graphs/weather.py:mk_weather_graph", "searchy": "./tests/graphs/searchy.py:graph", "agent_simple": "./tests/graphs/agent_simple.py:graph", "simple_runtime": "./tests/graphs/simple_runtime.py:graph", "agent_interrupt": "./tests/graphs/agent_interrupt.py:graph", "message_type_test": "./tests/graphs/message_type_test.py:graph", "remote_subgraph_parent": "./tests/graphs/remote_subgraph_parent.py:graph", "simple_remote": "./tests/graphs/simple_remote.py:graph", "nested_subgraphs": "./tests/graphs/nested_subgraphs.py:graph", "functional_fibonacci": "./tests/graphs/functional_fibonacci.py:fibonacci", "state_graph_fibonacci": "./tests/graphs/state_graph_fibonacci.py:fibonacci", "max_concurrency_graph": "./tests/graphs/max_concurrency_graph.py:graph", "unserializable_subgraph": "./tests/graphs/unserializable_subgraph.py:graph", "agent_interrupt_text": "./tests/graphs/agent_interrupt_text.py:graph", "agent_echo_stream": "./tests/graphs/agent_echo_stream.py:graph", "runtime_graph": "./tests/graphs/runtime_graph.py:graph", "tool_call_chunk_stream": "./tests/graphs/tool_call_chunk_stream.py:graph"}'
+LANGSERVE_GRAPHS_ALL = '{"agent": {"path": "./tests/graphs/agent.py:graph", "description": "agent"}, "assistant_id_runtime": "./tests/graphs/assistant_id_runtime.py:graph", "custom_lifespan": "./tests/graphs/my_router.py:graph", "single_node": "./tests/graphs/single_node.py:graph", "benchmark": "./tests/graphs/benchmark.py:graph", "config_graph": "./tests/graphs/config_graph.py:graph", "other": "./tests/graphs/other.py:make_graph", "weather": "./tests/graphs/weather.py:mk_weather_graph", "searchy": "./tests/graphs/searchy.py:graph", "agent_simple": "./tests/graphs/agent_simple.py:graph", "simple_runtime": "./tests/graphs/simple_runtime.py:graph", "agent_interrupt": "./tests/graphs/agent_interrupt.py:graph", "message_type_test": "./tests/graphs/message_type_test.py:graph", "remote_subgraph_parent": "./tests/graphs/remote_subgraph_parent.py:graph", "simple_remote": "./tests/graphs/simple_remote.py:graph", "nested_subgraphs": "./tests/graphs/nested_subgraphs.py:graph", "functional_fibonacci": "./tests/graphs/functional_fibonacci.py:fibonacci", "state_graph_fibonacci": "./tests/graphs/state_graph_fibonacci.py:fibonacci", "max_concurrency_graph": "./tests/graphs/max_concurrency_graph.py:graph", "unserializable_subgraph": "./tests/graphs/unserializable_subgraph.py:graph", "agent_interrupt_text": "./tests/graphs/agent_interrupt_text.py:graph", "agent_echo_stream": "./tests/graphs/agent_echo_stream.py:graph", "runtime_graph": "./tests/graphs/runtime_graph.py:graph", "tool_call_chunk_stream": "./tests/graphs/tool_call_chunk_stream.py:graph", "ui_tool_call_stream": "./tests/graphs/ui_tool_call_stream.py:graph"}'
 LANGSERVE_GRAPHS_AUTH = '{"agent": {"path": "./tests/graphs/agent.py:graph", "description": "agent"}, "assistant_id_runtime": "./tests/graphs/assistant_id_runtime.py:graph", "config_graph": "./tests/graphs/config_graph.py:graph", "other": "./tests/graphs/other.py:make_graph", "weather": "./tests/graphs/weather.py:mk_weather_graph", "searchy": "./tests/graphs/searchy.py:graph", "agent_simple": "./tests/graphs/agent_simple.py:graph", "simple_runtime": "./tests/graphs/simple_runtime.py:graph", "functional_fibonacci": "./tests/graphs/functional_fibonacci.py:fibonacci", "state_graph_fibonacci": "./tests/graphs/state_graph_fibonacci.py:fibonacci", "runtime_graph": "./tests/graphs/runtime_graph.py:graph"}'
 
 # Go server management

{langgraph_api-0.7.94 → langgraph_api-0.7.95}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.7.94
+Version: 0.7.95
 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.7.94 → langgraph_api-0.7.95}/benchmark/Makefile

@@ -1,7 +1,7 @@
 # Benchmark commands
 
 # Capacity benchmark
-CLUSTER_NAME ?= dr-small
+CLUSTER_NAME ?= dr-1-node
 # WORKLOAD_NAMES supports comma-separated list (e.g., "parallel-small,parallel-tiny")
 # Falls back to WORKLOAD_NAME for backwards compatibility
 WORKLOAD_NAMES ?= $(WORKLOAD_NAME)

langgraph_api-0.7.95/benchmark/README.md

@@ -0,0 +1,152 @@
+# Benchmarking
+
+This directory contains k6 + Python/Node benchmark tooling for LangGraph API.
+
+## Available Commands
+
+- `make benchmark-ramp` - Ramps up to a set number of concurrent virtual users, holds plateau load, then ramps down.
+  - **Environment variables:**
+    - `LOAD_SIZE`, `LEVELS`, `PLATEAU_DURATION`
+    - `P95_RUN_DURATION`, `AVERAGE_RUN_DURATION`
+  - **Example:**
+    - `BENCHMARK_PROFILE=streaming-long BENCHMARK_TYPE=stream_write LOAD_SIZE=300 LEVELS=3 make benchmark-ramp`
+
+- `make benchmark-staircase` - Runs stepwise capacity testing with SLO checks and a final staircase summary.
+  - **Environment variables:**
+    - `K6_EXECUTOR`, `START_LOAD`, `STEP_SIZE`, `NUM_STEPS`, `PLATEAU_DURATION`
+    - `MAX_VUS`, `MAX_VUS_MULTIPLIER`, `PRE_ALLOCATED_VUS`
+    - `WARMUP_ITERS`, `COOLDOWN_DURATION`
+    - `MIN_SUCCESS_RATE`, `MAX_P50_DURATION_MS`, `MAX_P95_DURATION_MS`, `ABORT_ERROR_RATE`
+  - **Example:**
+    - `BENCHMARK_PROFILE=parallel-small START_LOAD=30 STEP_SIZE=15 NUM_STEPS=10 make benchmark-staircase`
+
+- `make benchmark-capacity` - Runs binary-search capacity tests and writes `capacity_summary.json`.
+  - **Environment variables:**
+    - `CLUSTER_NAME`
+    - `WORKLOAD_NAMES` (comma-separated) or `WORKLOAD_NAME`
+  - **Support note:** `BENCHMARK_TYPE` is supported but usually determined by profile/workload defaults.
+  - **Example:**
+    - `CLUSTER_NAME=dr-1-node WORKLOAD_NAMES=parallel-small,parallel-medium make benchmark-capacity`
+
+- `make benchmark-mixed` - Runs quick and long workloads concurrently to measure contention/fairness.
+  - **Environment variables:**
+    - `SLOWEST_N`
+    - Quick workload knobs: `QUICK_VUS`, `QUICK_ITERATIONS`, `QUICK_STEPS`, `QUICK_DATA_SIZE`, `QUICK_MAX_WAIT_SECONDS`, `QUICK_POLL_INTERVAL`
+    - Long workload knobs: `LONG_VUS`, `LONG_ITERATIONS`, `LONG_STEPS`, `LONG_DELAY`, `LONG_DATA_SIZE`, `LONG_MAX_WAIT_SECONDS`, `LONG_POLL_INTERVAL`
+  - **Support note:** Does **not** support benchmark universal/profile/context knobs (`BENCHMARK_TYPE`, `BENCHMARK_PROFILE`, `RUN_MODE`, `STREAM_RESUMABLE`, or context overrides). Only mixed-workload vars + generic `BASE_URL`/`LANGSMITH_API_KEY` apply.
+  - **Example:**
+    - `BASE_URL=http://localhost:9123 QUICK_VUS=300 LONG_VUS=8 LONG_STEPS=60 make benchmark-mixed`
+
+- `make benchmark-charts` - Builds charts from the latest `raw_data_*.json` ramp output. Only works for ramp.
+- `make benchmark-clean` - Deletes local benchmark result/chart artifacts.
+- `make benchmark-reset` - Cleans benchmark server state via `clean-cli.js`.
+- `make benchmark-new-revision` - Triggers a new benchmark deployment revision.
+
+## Benchmark runner types (`BENCHMARK_TYPE`)
+
+The runner contains the actual logic each virtual user will execute during the benchmark and steps to validate the logic worked correctly. Options are:
+
+- `wait_write` - Uses `/runs/wait` and validates completion plus expected counter progression.
+- `stream_write` - Uses `/runs/stream` with `stream_mode=['values','messages']` and validates streamed events.
+- `assistants` - Benchmarks assistant CRUD/list style API behavior.
+- `threads` - Benchmarks thread CRUD/list style API behavior.
+- `enqueued_runs_order` - Enqueues multiple runs and validates completion ordering behavior.
+- `cancel_first_second_completes` - Starts two runs, cancels one, and validates cancellation semantics.
+- `thread_runs_metadata_search` - Creates a run and validates filtering/search by run metadata.
+- `threads_search_metadata` - Validates thread metadata search/filter behavior.
+- `meta_workload` (randomly delegates to one of the others)
+
+## Profiles (`BENCHMARK_PROFILE`)
+
+Profiles are quick ways to configure the benchmark graph for any run depending on the use case.
+
+- `default` - Baseline single-step stateless profile with small checkpoint writes.
+- `streaming-long` - Long-running stateful streaming profile with 2KB regular chunks and occasional 2MB spikes.
+- `stateless-parallel-small` - Stateless high-fanout profile with small checkpoint payloads.
+- `stateless-parallel-medium` - Stateless high-fanout profile with medium checkpoint payloads.
+- `parallel-small` - Stateful high-fanout profile with small checkpoint payloads.
+- `parallel-medium` - Stateful high-fanout profile with medium checkpoint payloads.
+
+Each profile defines:
+
+- `context` (delay/steps/checkpoint/streaming/burst knobs)
+- `capacity` defaults (`runMode`, `rampEndBase`, `runExecutionTimeoutSeconds`)
+- `resumable` default (can be overridden by `STREAM_RESUMABLE`)
+
+## Core environment knobs
+
+Common:
+
+- `BASE_URL` - Target LangGraph API endpoint for benchmark traffic.
+- `LANGSMITH_API_KEY` - API key used for authenticated benchmark deployments.
+- `BENCHMARK_TYPE` - Selects which runner implementation to execute.
+- `BENCHMARK_PROFILE` - Selects a named profile from `benchmark_profiles.ts`.
+- `RUN_MODE` (`stateless`/`stateful`) - Controls whether runs execute directly or via created threads.
+- `STREAM_RESUMABLE` - Overrides profile default for resumable stream persistence.
+
+Context overrides (merged on top of profile):
+
+- `DELAY` - Per-node sleep delay in seconds.
+- `DELAY_JITTER_RATIO` - Randomized delay spread ratio around `DELAY` (for desynchronizing requests).
+- `EXPAND` - Fanout width (number of parallel branches at start).
+- `STEPS` - Number of graph turns/iterations to execute.
+- `CHECKPOINT_SIZE` - Bytes written per checkpoint operation.
+- `LLM_ENABLED` - Enables fake LLM streaming inside the benchmark graph.
+- `STREAM_SIZE` - Normal total streamed payload size (bytes).
+- `CHUNK_SIZE` - Stream chunk size (bytes) when emitting payload.
+- `BURST_MODE` - Enables probabilistic burst streaming behavior.
+- `BURST_PROBABILITY` - Probability that a run uses burst payload size.
+- `BURST_SIZE` - Burst payload size (bytes) when burst mode triggers.
+
+## Common commands
+
+```bash
+# Ramp benchmark (default profile + wait_write unless overridden)
+make benchmark-ramp
+
+# Ramp with profile + stream runner
+BENCHMARK_PROFILE=streaming-long BENCHMARK_TYPE=stream_write make benchmark-ramp
+
+# Staircase benchmark
+make benchmark-staircase
+
+# Capacity benchmark (single workload)
+CLUSTER_NAME=dr-1-node WORKLOAD_NAME=parallel-small make benchmark-capacity
+
+# Capacity benchmark (multiple workloads)
+CLUSTER_NAME=dr-1-node WORKLOAD_NAMES=parallel-small,parallel-medium make benchmark-capacity
+
+# Mixed workload benchmark
+make benchmark-mixed
+
+# Build charts from latest ramp raw_data file
+make benchmark-charts
+
+# Remove local benchmark artifacts
+make benchmark-clean
+```
+
+## Outputs
+
+- Ramp:
+  - `raw_data_<timestamp>.json`
+  - `results_<timestamp>.json`
+  - `summary_<timestamp>.json`
+  - `*_chart_*.png` (when chart generation is run)
+- Staircase:
+  - `staircase_summary.json`
+- Capacity:
+  - `capacity_summary.json`
+- Mixed:
+  - `mixed_workload_*.json`
+
+## CI workflows
+
+- Daily ramp benchmark: `.github/workflows/benchmark.yml`
+- Capacity benchmark matrix: `.github/workflows/benchmark-capacity.yml`
+- Mixed benchmark matrix: `.github/workflows/benchmark-mixed.yml`
+
+## References
+
+- [k6 docs](https://k6.io/docs/)
+- [k6 JavaScript API](https://k6.io/docs/javascript-api/)

{langgraph_api-0.7.94 → langgraph_api-0.7.95}/benchmark/benchmark-runners/assistant.ts

@@ -23,7 +23,7 @@ export class Assistant extends BenchmarkRunner {
   static run(
     baseUrl: string,
     requestParams: Record<string, unknown>,
-    _benchmarkGraphOptions?: BenchmarkGraphOptions
+    _benchmarkGraphOptions: BenchmarkGraphOptions
   ): BenchmarkResult<AssistantData> {
     const graph_id = DEFAULT_GRAPH_ID;
     let metadata: Record<string, string> = {
@@ -73,7 +73,7 @@ export class Assistant extends BenchmarkRunner {
   static validate(
     result: BenchmarkResult<AssistantData>,
     errorMetrics: ErrorMetrics,
-    _benchmarkGraphOptions?: BenchmarkGraphOptions
+    _benchmarkGraphOptions: BenchmarkGraphOptions
   ): boolean {
     const d = result.data;
     if (!d) {

{langgraph_api-0.7.94 → langgraph_api-0.7.95}/benchmark/benchmark-runners/benchmark-runner.ts

@@ -16,7 +16,7 @@ export abstract class BenchmarkRunner {
   static run(
     _baseUrl: string,
     _requestParams: Record<string, unknown>,
-    _benchmarkGraphOptions?: BenchmarkGraphOptions
+    _benchmarkGraphOptions: BenchmarkGraphOptions
   ): BenchmarkResult<unknown> {
     throw new Error('Not implemented');
   }
@@ -28,7 +28,7 @@ export abstract class BenchmarkRunner {
   static validate(
     _result: BenchmarkResult<unknown>,
     _errorMetrics: ErrorMetrics,
-    _benchmarkGraphOptions?: BenchmarkGraphOptions
+    _benchmarkGraphOptions: BenchmarkGraphOptions
   ): boolean {
     throw new Error('Not implemented');
   }

langgraph_api-0.7.95/benchmark/benchmark-runners/benchmark_profiles.ts

@@ -0,0 +1,263 @@
+export interface BenchmarkContext {
+  delay: number;
+  delay_jitter_ratio: number;
+  expand: number;
+  steps: number;
+  checkpoint_size: number;
+  llm_enabled: boolean;
+  stream_size: number;
+  chunk_size: number;
+  burst_mode: boolean;
+  burst_probability: number;
+  burst_size: number;
+}
+
+export interface BenchmarkProfileEnv {
+  BENCHMARK_PROFILE?: string;
+  BENCHMARK_TYPE?: string;
+  RUN_MODE?: string;
+  STREAM_RESUMABLE?: string;
+  DELAY?: string;
+  DELAY_JITTER_RATIO?: string;
+  EXPAND?: string;
+  STEPS?: string;
+  CHECKPOINT_SIZE?: string;
+  LLM_ENABLED?: string;
+  STREAM_SIZE?: string;
+  CHUNK_SIZE?: string;
+  BURST_MODE?: string;
+  BURST_PROBABILITY?: string;
+  BURST_SIZE?: string;
+}
+
+export interface CapacityProfileSettings {
+  runMode: 'stateless' | 'stateful';
+  rampEndBase: number;
+  runExecutionTimeoutSeconds: number;
+}
+
+export interface BenchmarkProfile {
+  context: BenchmarkContext;
+  resumable: boolean;
+  capacity: CapacityProfileSettings;
+}
+
+export interface ParsedBenchmarkProfile {
+  name: string;
+  benchmarkType: string;
+  runMode: 'stateless' | 'stateful';
+  resumable: boolean;
+  context: BenchmarkContext;
+  capacity: CapacityProfileSettings;
+}
+
+const DEFAULT_PROFILE_NAME = 'default';
+
+export const BENCHMARK_PROFILES: Record<string, BenchmarkProfile> = {
+  default: {
+    resumable: false,
+    context: {
+      delay: 0,
+      delay_jitter_ratio: 0.2,
+      expand: 1,
+      steps: 1,
+      checkpoint_size: 1024,
+      llm_enabled: false,
+      stream_size: 0,
+      chunk_size: 1,
+      burst_mode: false,
+      burst_probability: 0,
+      burst_size: 0,
+    },
+    capacity: {
+      runMode: 'stateless',
+      rampEndBase: 200,
+      runExecutionTimeoutSeconds: 60,
+    },
+  },
+  'streaming-long': {
+    resumable: true,
+    context: {
+      delay: 0.5,
+      delay_jitter_ratio: 0.2,
+      expand: 1,
+      steps: 300,
+      checkpoint_size: 0,
+      llm_enabled: true,
+      stream_size: 2 * 1024,
+      chunk_size: 2 * 1024,
+      burst_mode: true,
+      burst_probability: 0.05,
+      burst_size: 2 * 1024 * 1024,
+    },
+    capacity: {
+      runMode: 'stateful',
+      rampEndBase: 20,
+      runExecutionTimeoutSeconds: 1000,
+    },
+  },
+  'stateless-parallel-small': {
+    resumable: false,
+    context: {
+      delay: 0,
+      delay_jitter_ratio: 0.2,
+      expand: 100,
+      steps: 1,
+      checkpoint_size: 1_000,
+      llm_enabled: false,
+      stream_size: 0,
+      chunk_size: 1,
+      burst_mode: false,
+      burst_probability: 0,
+      burst_size: 0,
+    },
+    capacity: {
+      runMode: 'stateless',
+      rampEndBase: 200,
+      runExecutionTimeoutSeconds: 60,
+    },
+  },
+  'stateless-parallel-medium': {
+    resumable: false,
+    context: {
+      delay: 0,
+      delay_jitter_ratio: 0.2,
+      expand: 100,
+      steps: 1,
+      checkpoint_size: 10_000,
+      llm_enabled: false,
+      stream_size: 0,
+      chunk_size: 1,
+      burst_mode: false,
+      burst_probability: 0,
+      burst_size: 0,
+    },
+    capacity: {
+      runMode: 'stateless',
+      rampEndBase: 200,
+      runExecutionTimeoutSeconds: 60,
+    },
+  },
+  'parallel-small': {
+    resumable: false,
+    context: {
+      delay: 0,
+      delay_jitter_ratio: 0.2,
+      expand: 100,
+      steps: 1,
+      checkpoint_size: 1_000,
+      llm_enabled: false,
+      stream_size: 0,
+      chunk_size: 1,
+      burst_mode: false,
+      burst_probability: 0,
+      burst_size: 0,
+    },
+    capacity: {
+      runMode: 'stateful',
+      rampEndBase: 200,
+      runExecutionTimeoutSeconds: 60,
+    },
+  },
+  'parallel-medium': {
+    resumable: false,
+    context: {
+      delay: 0,
+      delay_jitter_ratio: 0.2,
+      expand: 100,
+      steps: 1,
+      checkpoint_size: 10_000,
+      llm_enabled: false,
+      stream_size: 0,
+      chunk_size: 1,
+      burst_mode: false,
+      burst_probability: 0,
+      burst_size: 0,
+    },
+    capacity: {
+      runMode: 'stateful',
+      rampEndBase: 200,
+      runExecutionTimeoutSeconds: 60,
+    },
+  },
+};
+
+export function getBenchmarkProfile(profileName?: string): { name: string; profile: BenchmarkProfile } {
+  const resolvedName = profileName || DEFAULT_PROFILE_NAME;
+  const profile = BENCHMARK_PROFILES[resolvedName];
+  if (!profile) {
+    throw new Error(
+      `Unknown BENCHMARK_PROFILE: "${profileName}". Must be one of: ${Object.keys(BENCHMARK_PROFILES).join(', ')}`
+    );
+  }
+  return { name: resolvedName, profile };
+}
+
+export function resolveBenchmarkContext(
+  profileName: string | undefined,
+  overrides: Partial<BenchmarkContext> = {}
+): BenchmarkContext {
+  const { profile } = getBenchmarkProfile(profileName);
+  return {
+    ...profile.context,
+    ...overrides,
+  };
+}
+
+/**
+ * There are two possible counts for expected events: normal and burst.
+ * ratio * (expected_steps * expand) + 2 will be the min, but could be larger if we hit bursts.
+ */
+export function getExpectedEvents(context: BenchmarkContext): number {
+  return (3 + context.stream_size / context.chunk_size) * (context.steps * context.expand) + 2;
+}
+
+function parseOptionalInt(value?: string): number | undefined {
+  if (value == null || value === '') return undefined;
+  return parseInt(value, 10);
+}
+
+function parseOptionalFloat(value?: string): number | undefined {
+  if (value == null || value === '') return undefined;
+  return parseFloat(value);
+}
+
+function parseOptionalBool(value?: string): boolean | undefined {
+  if (value == null || value === '') return undefined;
+  return value === 'true';
+}
+
+export function get_profile(env: BenchmarkProfileEnv): ParsedBenchmarkProfile {
+  const profileName = env.BENCHMARK_PROFILE;
+  const { name, profile } = getBenchmarkProfile(profileName);
+  const context = resolveBenchmarkContext(name, {
+    ...(parseOptionalFloat(env.DELAY) !== undefined ? { delay: parseOptionalFloat(env.DELAY)! } : {}),
+    ...(parseOptionalFloat(env.DELAY_JITTER_RATIO) !== undefined
+      ? { delay_jitter_ratio: parseOptionalFloat(env.DELAY_JITTER_RATIO)! }
+      : {}),
+    ...(parseOptionalInt(env.EXPAND) !== undefined ? { expand: parseOptionalInt(env.EXPAND)! } : {}),
+    ...(parseOptionalInt(env.STEPS) !== undefined ? { steps: parseOptionalInt(env.STEPS)! } : {}),
+    ...(parseOptionalInt(env.CHECKPOINT_SIZE) !== undefined ? { checkpoint_size: parseOptionalInt(env.CHECKPOINT_SIZE)! } : {}),
+    ...(parseOptionalBool(env.LLM_ENABLED) !== undefined ? { llm_enabled: parseOptionalBool(env.LLM_ENABLED)! } : {}),
+    ...(parseOptionalInt(env.STREAM_SIZE) !== undefined ? { stream_size: parseOptionalInt(env.STREAM_SIZE)! } : {}),
+    ...(parseOptionalInt(env.CHUNK_SIZE) !== undefined ? { chunk_size: parseOptionalInt(env.CHUNK_SIZE)! } : {}),
+    ...(parseOptionalBool(env.BURST_MODE) !== undefined ? { burst_mode: parseOptionalBool(env.BURST_MODE)! } : {}),
+    ...(parseOptionalFloat(env.BURST_PROBABILITY) !== undefined
+      ? { burst_probability: parseOptionalFloat(env.BURST_PROBABILITY)! }
+      : {}),
+    ...(parseOptionalInt(env.BURST_SIZE) !== undefined ? { burst_size: parseOptionalInt(env.BURST_SIZE)! } : {}),
+  });
+
+  return {
+    name,
+    benchmarkType: env.BENCHMARK_TYPE || 'wait_write',
+    runMode: env.RUN_MODE ? (env.RUN_MODE === 'stateful' ? 'stateful' : 'stateless') : profile.capacity.runMode,
+    resumable: env.STREAM_RESUMABLE != null && env.STREAM_RESUMABLE !== ''
+      ? parseOptionalBool(env.STREAM_RESUMABLE) ?? profile.resumable
+      : profile.resumable,
+    context,
+    capacity: profile.capacity,
+  };
+}
+
+

{langgraph_api-0.7.94 → langgraph_api-0.7.95}/benchmark/benchmark-runners/benchmarks.ts

@@ -6,7 +6,6 @@ import { EnqueuedRunsOrder } from './enqueued_runs_order.js';
 import { CancelFirstSecondCompletes } from './cancel_first_second_completes.js';
 import { ThreadRunsMetadataSearch } from './thread_runs_metadata_search.js';
 import { ThreadsSearchMetadata } from './threads_search_metadata.js';
-import { RandomStream } from './random_stream.js';
 import { MetaWorkload } from './meta_workload.js';
 import type { BenchmarkRunner } from './benchmark-runner.js';
 
@@ -29,8 +28,6 @@ export class Benchmarks {
         return ThreadRunsMetadataSearch;
       case ThreadsSearchMetadata.toString():
         return ThreadsSearchMetadata;
-      case RandomStream.toString():
-        return RandomStream;
       case MetaWorkload.toString():
         return MetaWorkload;
       default:

{langgraph_api-0.7.94 → langgraph_api-0.7.95}/benchmark/benchmark-runners/cancel_first_second_completes.ts

@@ -3,7 +3,7 @@ import type { ErrorMetrics } from './benchmark-runner.js';
 import { check } from 'k6';
 import http from 'k6/http';
 import type { BenchmarkResult, BenchmarkGraphOptions } from './types.js';
-import { DEFAULT_GRAPH_ID, JOIN_TIMEOUT } from './types.js';
+import { JOIN_TIMEOUT } from './types.js';
 import { addResponse, failResult, okResult } from './types.js';
 import { logFailure } from './log-failure.js';
 
@@ -19,12 +19,13 @@ export class CancelFirstSecondCompletes extends BenchmarkRunner {
   static run(
     baseUrl: string,
     requestParams: Record<string, unknown>,
-    benchmarkGraphOptions?: BenchmarkGraphOptions
+    benchmarkGraphOptions: BenchmarkGraphOptions
   ): BenchmarkResult<CancelFirstSecondCompletesData> {
-    const graphId = benchmarkGraphOptions?.graph_id ?? DEFAULT_GRAPH_ID;
+    const graphId = benchmarkGraphOptions.graph_id;
     const longDelaySec = 3;
     const responses: Record<string, import('./types.js').HttpResponse> = {};
     const joinParams = { ...requestParams, timeout: JOIN_TIMEOUT };
+    const baseContext = benchmarkGraphOptions.context;
 
     const createThreadRes = http.post(`${baseUrl}/threads`, '{}', requestParams);
     addResponse(responses, 'create_thread', createThreadRes);
@@ -35,7 +36,8 @@ export class CancelFirstSecondCompletes extends BenchmarkRunner {
 
     const run1Payload = JSON.stringify({
       assistant_id: graphId,
-      input: { mode: 'single', delay: longDelaySec, expand: 1, steps: 1 },
+      input: {},
+      context: { ...baseContext, delay: longDelaySec, expand: 1, steps: 1 },
       config: { recursion_limit: 5 },
     });
     const run1Res = http.post(`${baseUrl}/threads/${threadId}/runs`, run1Payload, requestParams);
@@ -47,7 +49,8 @@ export class CancelFirstSecondCompletes extends BenchmarkRunner {
 
     const run2Payload = JSON.stringify({
       assistant_id: graphId,
-      input: { mode: 'single', delay: 0, expand: 1, steps: 1 },
+      input: {},
+      context: { ...baseContext, delay: 0, expand: 1, steps: 1 },
       config: { recursion_limit: 5 },
       multitask_strategy: 'enqueue',
     });
@@ -85,7 +88,7 @@ export class CancelFirstSecondCompletes extends BenchmarkRunner {
   static validate(
     result: BenchmarkResult<CancelFirstSecondCompletesData>,
     errorMetrics: ErrorMetrics,
-    _benchmarkGraphOptions?: BenchmarkGraphOptions
+    _benchmarkGraphOptions: BenchmarkGraphOptions
   ): boolean {
     if (!result.ok) {
       logFailure(CancelFirstSecondCompletes.toString(), result);

{langgraph_api-0.7.94 → langgraph_api-0.7.95}/benchmark/benchmark-runners/enqueued_runs_order.ts

@@ -3,7 +3,7 @@ import type { ErrorMetrics } from './benchmark-runner.js';
 import { check } from 'k6';
 import http from 'k6/http';
 import type { BenchmarkResult, BenchmarkGraphOptions } from './types.js';
-import { DEFAULT_GRAPH_ID, DEFAULT_INPUT, JOIN_TIMEOUT, NUM_ENQUEUED_RUNS } from './types.js';
+import { JOIN_TIMEOUT, NUM_ENQUEUED_RUNS } from './types.js';
 import { addResponse, failResult, okResult } from './types.js';
 import { logFailure } from './log-failure.js';
 
@@ -17,11 +17,13 @@ export class EnqueuedRunsOrder extends BenchmarkRunner {
   static run(
     baseUrl: string,
     requestParams: Record<string, unknown>,
-    benchmarkGraphOptions?: BenchmarkGraphOptions
+    benchmarkGraphOptions: BenchmarkGraphOptions
   ): BenchmarkResult<EnqueuedRunsOrderData> {
-    const graphId = benchmarkGraphOptions?.graph_id ?? DEFAULT_GRAPH_ID;
+    const graphId = benchmarkGraphOptions.graph_id;
     const responses: Record<string, import('./types.js').HttpResponse> = {};
     const joinParams = { ...requestParams, timeout: JOIN_TIMEOUT } as Record<string, unknown>;
+    const context = benchmarkGraphOptions.context;
+    const recursion_limit = Math.max(context.expand, context.steps) + 2;
 
     const createThreadRes = http.post(`${baseUrl}/threads`, '{}', requestParams);
     addResponse(responses, 'create_thread', createThreadRes);
@@ -34,8 +36,9 @@ export class EnqueuedRunsOrder extends BenchmarkRunner {
     for (let i = 0; i < NUM_ENQUEUED_RUNS; i++) {
       const payload = JSON.stringify({
         assistant_id: graphId,
-        input: benchmarkGraphOptions?.input ?? DEFAULT_INPUT,
-        config: { recursion_limit: 5 },
+        input: {},
+        context,
+        config: { recursion_limit },
         multitask_strategy: 'enqueue',
       });
       const createRunRes = http.post(`${baseUrl}/threads/${threadId}/runs`, payload, requestParams);
@@ -64,7 +67,7 @@ export class EnqueuedRunsOrder extends BenchmarkRunner {
   static validate(
     result: BenchmarkResult<EnqueuedRunsOrderData>,
     errorMetrics: ErrorMetrics,
-    _benchmarkGraphOptions?: BenchmarkGraphOptions
+    _benchmarkGraphOptions: BenchmarkGraphOptions
   ): boolean {
     if (!result.ok) {
       logFailure(EnqueuedRunsOrder.toString(), result);

{langgraph_api-0.7.94 → langgraph_api-0.7.95}/benchmark/benchmark-runners/meta_workload.ts

@@ -10,7 +10,6 @@ import { EnqueuedRunsOrder } from './enqueued_runs_order.js';
 import { CancelFirstSecondCompletes } from './cancel_first_second_completes.js';
 import { ThreadRunsMetadataSearch } from './thread_runs_metadata_search.js';
 import { ThreadsSearchMetadata } from './threads_search_metadata.js';
-import { RandomStream } from './random_stream.js';
 
 const OTHER_RUNNERS = [
   WaitWrite,
@@ -21,7 +20,6 @@ const OTHER_RUNNERS = [
   CancelFirstSecondCompletes,
   ThreadRunsMetadataSearch,
   ThreadsSearchMetadata,
-  RandomStream,
 ];
 
 interface MetaWorkloadData {
@@ -34,14 +32,14 @@ export class MetaWorkload extends BenchmarkRunner {
   static run(
     baseUrl: string,
     requestParams: Record<string, unknown>,
-    benchmarkGraphOptions?: BenchmarkGraphOptions
+    benchmarkGraphOptions: BenchmarkGraphOptions
   ): BenchmarkResult<MetaWorkloadData> {
     const Runner = OTHER_RUNNERS[Math.floor(Math.random() * OTHER_RUNNERS.length)];
     const innerResult = Runner.run(baseUrl, requestParams, benchmarkGraphOptions) as BenchmarkResult;
     return {
       ok: innerResult.ok,
       step: innerResult.step,
-      responses: innerResult.responses ?? {},
+      responses: innerResult.responses,
       data: { type: Runner.toString(), result: innerResult, Runner },
     };
   }
@@ -49,7 +47,7 @@ export class MetaWorkload extends BenchmarkRunner {
   static validate(
     result: BenchmarkResult<MetaWorkloadData>,
     errorMetrics: ErrorMetrics,
-    benchmarkGraphOptions?: BenchmarkGraphOptions
+    benchmarkGraphOptions: BenchmarkGraphOptions
   ): boolean {
     const d = result.data;
     if (!d) {