langgraph-api 0.7.89__tar.gz → 0.7.91__tar.gz

{langgraph_api-0.7.89 → langgraph_api-0.7.91}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.7.89
+Version: 0.7.91
 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
@@ -14,7 +14,7 @@ Requires-Dist: httpx>=0.25.0
 Requires-Dist: jsonschema-rs<0.45,>=0.20.0
 Requires-Dist: langchain-core>=0.3.64
 Requires-Dist: langgraph-checkpoint<5,>=3.0.1
-Requires-Dist: langgraph-runtime-inmem<0.27.0,>=0.26.0
+Requires-Dist: langgraph-runtime-inmem<0.28.0,>=0.27.0
 Requires-Dist: langgraph-sdk>=0.3.5
 Requires-Dist: langgraph<2,>=0.4.10
 Requires-Dist: langsmith[otel]>=0.6.3
@@ -32,6 +32,7 @@ Requires-Dist: truststore>=0.1
 Requires-Dist: uuid-utils>=0.12.0
 Requires-Dist: uvicorn>=0.26.0
 Requires-Dist: watchfiles>=0.13
+Requires-Dist: zstandard>=0.23.0
 Description-Content-Type: text/markdown
 
 # LangGraph API

{langgraph_api-0.7.89 → langgraph_api-0.7.91}/benchmark/Makefile

@@ -18,17 +18,17 @@ DELAY ?= 0
 EXPAND ?= 1
 STEPS ?= 100
 
-benchmark-burst:
-	make benchmark-reset
-	k6 run burst.js
 
 benchmark-ramp:
 	make benchmark-reset
+	npm install
+	npm run build
 	k6 run --out json=raw_data_$(shell date +%Y-%m-%dT%H-%M-%S).json --system-tags=[] ramp.js
 
 benchmark-capacity:
 	rm -f capacity_summary.json
 	npm install
+	npm run build
 	LANGSMITH_API_KEY=$(LANGSMITH_API_KEY) \
 	CLUSTER_NAME=$(CLUSTER_NAME) \
 	WORKLOAD_NAMES=$(WORKLOAD_NAMES) \

{langgraph_api-0.7.89 → langgraph_api-0.7.91}/benchmark/README.md

@@ -6,11 +6,8 @@ K6 is a modern load testing tool that allows you to test the performance and rel
 
 ### Available Tests
 
-There are two modes of testing available:
-1. `Burst` - Kick off a burst of /run/wait requests.
-    Available Params:
-        BURST_SIZE - How many requests to run. Default: 100
-2. `Ramp` - Scale up the number of /run/wait requests and then plateau.
+Available test:
+1. `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: 500
         LEVELS - The number of times to ramp up. Default: 2
@@ -45,17 +42,11 @@ Available Params:
 ### Basic Usage
 
 ```bash
-# Run burst test with default burst size
-make benchmark-burst
-
-# Run burst test with custom burst size
-BURST_SIZE=500 make benchmark-burst
-
 # Run ramp test with a different mode and expand size
 MODE='parallel' EXPAND=100 make benchmark-ramp
 
-# Run burst test against a deployment
-BASE_URL=https://jdr-benchmark-1cfe27c4cd375e1c999f02f186f617f6.us.langgraph.app make benchmark-burst
+# Run ramp test against a deployment
+BASE_URL=https://jdr-benchmark-1cfe27c4cd375e1c999f02f186f617f6.us.langgraph.app make benchmark-ramp
 
 # Clean up result files
 make benchmark-clean
@@ -63,7 +54,7 @@ make benchmark-clean
 
 ### Output
 
-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.
+Summary results are written to stdout and persisted in a summary file. More detailed results for the same run are persisted in a results file.
 
 Charts can be created from the run locally using the `make benchmark-charts` command.
 

langgraph_api-0.7.91/benchmark/benchmark-runners/assistant.ts

@@ -0,0 +1,129 @@
+import { BenchmarkRunner } from './benchmark-runner.js';
+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 } from './types.js';
+import { addResponse, okResult } from './types.js';
+import { logFailure } from './log-failure.js';
+
+type K6Response = ReturnType<typeof http.post> | ReturnType<typeof http.get> | ReturnType<typeof http.del>;
+
+interface AssistantData {
+  assistantId: string;
+  searchResponse: K6Response;
+  getResponse: K6Response;
+  patchResponse: K6Response;
+  getResponse2: K6Response;
+  countResponse: K6Response;
+  deleteResponse: K6Response;
+}
+
+export class Assistant extends BenchmarkRunner {
+  static run(
+    baseUrl: string,
+    requestParams: Record<string, unknown>,
+    _benchmarkGraphOptions?: BenchmarkGraphOptions
+  ): BenchmarkResult<AssistantData> {
+    const graph_id = DEFAULT_GRAPH_ID;
+    let metadata: Record<string, string> = {
+      description: `Test benchmark assistant ${crypto.randomUUID()}`,
+      created_by: 'benchmark',
+    };
+    const responses: Record<string, import('./types.js').HttpResponse> = {};
+
+    const createPayload = JSON.stringify({ graph_id, metadata });
+    const createResponse = http.post(`${baseUrl}/assistants`, createPayload, requestParams);
+    addResponse(responses, 'create', createResponse);
+    const assistantId = (createResponse.json() as { assistant_id: string }).assistant_id;
+
+    const searchPayload = JSON.stringify({ graph_id, metadata, limit: 1 });
+    const searchResponse = http.post(`${baseUrl}/assistants/search`, searchPayload, requestParams);
+    addResponse(responses, 'search', searchResponse);
+
+    const getResponse = http.get(`${baseUrl}/assistants/${assistantId}`, requestParams);
+    addResponse(responses, 'get', getResponse);
+
+    metadata = { description: `Test benchmark assistant ${crypto.randomUUID()}` };
+    const patchPayload = JSON.stringify({ metadata });
+    const patchResponse = http.patch(`${baseUrl}/assistants/${assistantId}`, patchPayload, requestParams);
+    addResponse(responses, 'patch', patchResponse);
+
+    const getResponse2 = http.get(`${baseUrl}/assistants/${assistantId}`, requestParams);
+    addResponse(responses, 'get2', getResponse2);
+
+    const countPayload = JSON.stringify({ graph_id, metadata });
+    const countResponse = http.post(`${baseUrl}/assistants/count`, countPayload, requestParams);
+    addResponse(responses, 'count', countResponse);
+
+    const deleteResponse = http.del(`${baseUrl}/assistants/${assistantId}`, '{}', requestParams);
+    addResponse(responses, 'delete', deleteResponse);
+
+    return okResult(responses, {
+      assistantId,
+      searchResponse,
+      getResponse,
+      patchResponse,
+      getResponse2,
+      countResponse,
+      deleteResponse,
+    });
+  }
+
+  static validate(
+    result: BenchmarkResult<AssistantData>,
+    errorMetrics: ErrorMetrics,
+    _benchmarkGraphOptions?: BenchmarkGraphOptions
+  ): boolean {
+    const d = result.data;
+    if (!d) {
+      logFailure(Assistant.toString(), result);
+      errorMetrics.other_errors.add(1);
+      return false;
+    }
+    let success = false;
+    try {
+      success = check(result, {
+        'Search response contains a single assistant': () => (d.searchResponse.json() as unknown[]).length === 1,
+        'Search response contains the correct assistant': () =>
+          (d.searchResponse.json() as { assistant_id: string }[])[0].assistant_id === d.assistantId,
+        'Get response contains the correct assistant': () =>
+          (d.getResponse.json() as { assistant_id: string }).assistant_id === d.assistantId,
+        'Patch response contains the correct assistant': () =>
+          (d.patchResponse.json() as { assistant_id: string }).assistant_id === d.assistantId,
+        'Get response 2 contains the correct assistant': () =>
+          (d.getResponse2.json() as { assistant_id: string }).assistant_id === d.assistantId,
+        'Get response 2 contains the new description': () => {
+          const g2 = d.getResponse2.json() as { metadata?: { description?: string } };
+          const g1 = d.getResponse.json() as { metadata?: { description?: string } };
+          const p = d.patchResponse.json() as { metadata?: { description?: string } };
+          return g2.metadata?.description !== g1.metadata?.description && g2.metadata?.description === p.metadata?.description;
+        },
+        'Get response 2 contains the correct created_by': () =>
+          (d.getResponse2.json() as { metadata?: { created_by?: string } }).metadata?.created_by === 'benchmark',
+        'Count response contains the correct number of assistants': () =>
+          parseInt((d.countResponse.json() as unknown) as string, 10) === 1,
+        'Delete response is successful': () => (d.deleteResponse as { status?: number }).status === 204,
+      });
+    } catch (error) {
+      console.log(`Unknown error checking response: ${(error as Error).message}`);
+    }
+    if (!success) {
+      logFailure(Assistant.toString(), result);
+      const statuses = [d.searchResponse, d.getResponse, d.patchResponse, d.getResponse2, d.countResponse, d.deleteResponse]
+        .map((r) => (r as { status?: number }).status);
+      if (statuses.some((s) => s === 502)) {
+        errorMetrics.server_errors.add(1);
+      } else if (statuses.some((s) => s === 408)) {
+        errorMetrics.timeout_errors.add(1);
+      } else {
+        errorMetrics.other_errors.add(1);
+      }
+    }
+    return success;
+  }
+
+  static toString(): string {
+    return 'assistants';
+  }
+}

langgraph_api-0.7.91/benchmark/benchmark-runners/benchmark-runner.ts

@@ -0,0 +1,35 @@
+import type { BenchmarkResult, BenchmarkGraphOptions } from './types.js';
+
+export interface ErrorMetrics {
+  server_errors: { add(n: number): void };
+  timeout_errors: { add(n: number): void };
+  api_errors?: { add(n: number): void };
+  missing_message_errors?: { add(n: number): void };
+  other_errors: { add(n: number): void };
+}
+
+/**
+ * Abstract base for benchmark runners. All runners return BenchmarkResult
+ * and validate() receives that same shape.
+ */
+export abstract class BenchmarkRunner {
+  static run(
+    _baseUrl: string,
+    _requestParams: Record<string, unknown>,
+    _benchmarkGraphOptions?: BenchmarkGraphOptions
+  ): BenchmarkResult<unknown> {
+    throw new Error('Not implemented');
+  }
+
+  static toString(): string {
+    throw new Error('Not implemented');
+  }
+
+  static validate(
+    _result: BenchmarkResult<unknown>,
+    _errorMetrics: ErrorMetrics,
+    _benchmarkGraphOptions?: BenchmarkGraphOptions
+  ): boolean {
+    throw new Error('Not implemented');
+  }
+}

langgraph_api-0.7.91/benchmark/benchmark-runners/benchmarks.ts

@@ -0,0 +1,40 @@
+import { WaitWrite } from './wait_write.js';
+import { StreamWrite } from './stream_write.js';
+import { Assistant } from './assistant.js';
+import { Thread } from './thread.js';
+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';
+
+export class Benchmarks {
+  static getRunner(type: string): typeof BenchmarkRunner {
+    switch (type) {
+      case WaitWrite.toString():
+        return WaitWrite;
+      case StreamWrite.toString():
+        return StreamWrite;
+      case Assistant.toString():
+        return Assistant;
+      case Thread.toString():
+        return Thread;
+      case EnqueuedRunsOrder.toString():
+        return EnqueuedRunsOrder;
+      case CancelFirstSecondCompletes.toString():
+        return CancelFirstSecondCompletes;
+      case ThreadRunsMetadataSearch.toString():
+        return ThreadRunsMetadataSearch;
+      case ThreadsSearchMetadata.toString():
+        return ThreadsSearchMetadata;
+      case RandomStream.toString():
+        return RandomStream;
+      case MetaWorkload.toString():
+        return MetaWorkload;
+      default:
+        throw new Error(`Unknown benchmark type: ${type}`);
+    }
+  }
+}

langgraph_api-0.7.91/benchmark/benchmark-runners/cancel_first_second_completes.ts

@@ -0,0 +1,116 @@
+import { BenchmarkRunner } from './benchmark-runner.js';
+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 { addResponse, failResult, okResult } from './types.js';
+import { logFailure } from './log-failure.js';
+
+interface CancelFirstSecondCompletesData {
+  threadId: string;
+  run1Id: string;
+  run2Id: string;
+  run1Final: { status: string } | null;
+  run2: { status: string } | null;
+}
+
+export class CancelFirstSecondCompletes extends BenchmarkRunner {
+  static run(
+    baseUrl: string,
+    requestParams: Record<string, unknown>,
+    benchmarkGraphOptions?: BenchmarkGraphOptions
+  ): BenchmarkResult<CancelFirstSecondCompletesData> {
+    const graphId = benchmarkGraphOptions?.graph_id ?? DEFAULT_GRAPH_ID;
+    const longDelaySec = 3;
+    const responses: Record<string, import('./types.js').HttpResponse> = {};
+    const joinParams = { ...requestParams, timeout: JOIN_TIMEOUT };
+
+    const createThreadRes = http.post(`${baseUrl}/threads`, '{}', requestParams);
+    addResponse(responses, 'create_thread', createThreadRes);
+    if (createThreadRes.status !== 200) {
+      return failResult('create_thread', responses) as BenchmarkResult<CancelFirstSecondCompletesData>;
+    }
+    const threadId = (createThreadRes.json() as { thread_id: string }).thread_id;
+
+    const run1Payload = JSON.stringify({
+      assistant_id: graphId,
+      input: { mode: 'single', delay: longDelaySec, expand: 1, steps: 1 },
+      config: { recursion_limit: 5 },
+    });
+    const run1Res = http.post(`${baseUrl}/threads/${threadId}/runs`, run1Payload, requestParams);
+    addResponse(responses, 'run1', run1Res);
+    if (run1Res.status !== 200) {
+      return failResult('create_run1', responses) as BenchmarkResult<CancelFirstSecondCompletesData>;
+    }
+    const run1Id = (run1Res.json() as { run_id: string }).run_id;
+
+    const run2Payload = JSON.stringify({
+      assistant_id: graphId,
+      input: { mode: 'single', delay: 0, expand: 1, steps: 1 },
+      config: { recursion_limit: 5 },
+      multitask_strategy: 'enqueue',
+    });
+    const run2Res = http.post(`${baseUrl}/threads/${threadId}/runs`, run2Payload, requestParams);
+    addResponse(responses, 'run2', run2Res);
+    if (run2Res.status !== 200) {
+      return failResult('create_run2', responses) as BenchmarkResult<CancelFirstSecondCompletesData>;
+    }
+    const run2Id = (run2Res.json() as { run_id: string }).run_id;
+
+    const cancelRes = http.post(
+      `${baseUrl}/threads/${threadId}/runs/${run1Id}/cancel?wait=false`,
+      '{}',
+      requestParams
+    );
+    addResponse(responses, 'cancel', cancelRes);
+    if (cancelRes.status !== 202 && cancelRes.status !== 200) {
+      return failResult('cancel_run1', responses) as BenchmarkResult<CancelFirstSecondCompletesData>;
+    }
+
+    const run1GetRes = http.get(`${baseUrl}/threads/${threadId}/runs/${run1Id}/join`, joinParams);
+    addResponse(responses, 'join_run1', run1GetRes);
+    const run1Final = run1GetRes.status === 200 ? (run1GetRes.json() as { status: string }) : null;
+
+    const run2JoinRes = http.get(`${baseUrl}/threads/${threadId}/runs/${run2Id}/join`, joinParams);
+    addResponse(responses, 'join_run2', run2JoinRes);
+    if (run2JoinRes.status !== 200) {
+      return failResult('join_run2', responses) as BenchmarkResult<CancelFirstSecondCompletesData>;
+    }
+    const run2 = run2JoinRes.json() as { status: string };
+
+    return okResult(responses, { threadId, run1Id, run2Id, run1Final, run2 });
+  }
+
+  static validate(
+    result: BenchmarkResult<CancelFirstSecondCompletesData>,
+    errorMetrics: ErrorMetrics,
+    _benchmarkGraphOptions?: BenchmarkGraphOptions
+  ): boolean {
+    if (!result.ok) {
+      logFailure(CancelFirstSecondCompletes.toString(), result);
+      const statuses = Object.values(result.responses).map((r) => r.status);
+      if (statuses.some((s) => s != null && s >= 500)) {
+        errorMetrics.server_errors.add(1);
+      } else {
+        errorMetrics.other_errors.add(1);
+      }
+      return false;
+    }
+    const d = result.data!;
+    const success = check(result, {
+      'Run 1 was cancelled or interrupted': () =>
+        Boolean(d.run1Final && (d.run1Final.status === 'cancelled' || d.run1Final.status === 'interrupted')),
+      'Run 2 completed successfully': () => d.run2?.status === 'success',
+    });
+    if (!success) {
+      logFailure(CancelFirstSecondCompletes.toString(), result);
+      errorMetrics.other_errors.add(1);
+    }
+    return success;
+  }
+
+  static toString(): string {
+    return 'cancel_first_second_completes';
+  }
+}

langgraph_api-0.7.91/benchmark/benchmark-runners/enqueued_runs_order.ts

@@ -0,0 +1,100 @@
+import { BenchmarkRunner } from './benchmark-runner.js';
+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 { addResponse, failResult, okResult } from './types.js';
+import { logFailure } from './log-failure.js';
+
+interface EnqueuedRunsOrderData {
+  threadId: string;
+  runIds: string[];
+  completedAt: Array<{ runId: string; status: string; updated_at: string }>;
+}
+
+export class EnqueuedRunsOrder extends BenchmarkRunner {
+  static run(
+    baseUrl: string,
+    requestParams: Record<string, unknown>,
+    benchmarkGraphOptions?: BenchmarkGraphOptions
+  ): BenchmarkResult<EnqueuedRunsOrderData> {
+    const graphId = benchmarkGraphOptions?.graph_id ?? DEFAULT_GRAPH_ID;
+    const responses: Record<string, import('./types.js').HttpResponse> = {};
+    const joinParams = { ...requestParams, timeout: JOIN_TIMEOUT } as Record<string, unknown>;
+
+    const createThreadRes = http.post(`${baseUrl}/threads`, '{}', requestParams);
+    addResponse(responses, 'create_thread', createThreadRes);
+    if (createThreadRes.status !== 200) {
+      return failResult(undefined, responses) as BenchmarkResult<EnqueuedRunsOrderData>;
+    }
+    const threadId = (createThreadRes.json() as { thread_id: string }).thread_id;
+
+    const runIds: string[] = [];
+    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 },
+        multitask_strategy: 'enqueue',
+      });
+      const createRunRes = http.post(`${baseUrl}/threads/${threadId}/runs`, payload, requestParams);
+      addResponse(responses, `create_run_${i}`, createRunRes);
+      if (createRunRes.status !== 200) {
+        return failResult(`create_run_${i}`, responses) as BenchmarkResult<EnqueuedRunsOrderData>;
+      }
+      runIds.push((createRunRes.json() as { run_id: string }).run_id);
+    }
+
+    const completedAt: EnqueuedRunsOrderData['completedAt'] = [];
+    for (let i = 0; i < NUM_ENQUEUED_RUNS; i++) {
+      const runId = runIds[i];
+      const joinRes = http.get(`${baseUrl}/threads/${threadId}/runs/${runId}/join`, joinParams);
+      addResponse(responses, `join_run_${i}`, joinRes);
+      if (joinRes.status !== 200) {
+        return failResult(`join_run_${i}`, responses) as BenchmarkResult<EnqueuedRunsOrderData>;
+      }
+      const run = joinRes.json() as { status: string; updated_at: string };
+      completedAt.push({ runId, status: run.status, updated_at: run.updated_at });
+    }
+
+    return okResult(responses, { threadId, runIds, completedAt });
+  }
+
+  static validate(
+    result: BenchmarkResult<EnqueuedRunsOrderData>,
+    errorMetrics: ErrorMetrics,
+    _benchmarkGraphOptions?: BenchmarkGraphOptions
+  ): boolean {
+    if (!result.ok) {
+      logFailure(EnqueuedRunsOrder.toString(), result);
+      const statuses = Object.values(result.responses).map((r) => r.status);
+      if (statuses.some((s) => s != null && s >= 500)) {
+        errorMetrics.server_errors.add(1);
+      } else {
+        errorMetrics.other_errors.add(1);
+      }
+      return false;
+    }
+    const d = result.data!;
+    const success = check(result, {
+      'All runs completed': () => d.completedAt.length === NUM_ENQUEUED_RUNS,
+      'All runs succeeded': () => d.completedAt.every((c) => c.status === 'success'),
+      'Runs completed in order': () => {
+        const times = d.completedAt.map((c) => new Date(c.updated_at).getTime());
+        return times[0] <= times[1] && times[1] <= times[2];
+      },
+    });
+    if (!success) {
+      logFailure(EnqueuedRunsOrder.toString(), result, {
+        extra: `completedAt=${JSON.stringify(d.completedAt)}`,
+      });
+      errorMetrics.other_errors.add(1);
+    }
+    return success;
+  }
+
+  static toString(): string {
+    return 'enqueued_runs_order';
+  }
+}

langgraph_api-0.7.91/benchmark/benchmark-runners/log-failure.ts

@@ -0,0 +1,38 @@
+import type { BenchmarkResult } from './types.js';
+
+export interface LogFailureOptions {
+  extra?: string;
+}
+
+/**
+ * Log useful information when a benchmark run or validation fails.
+ * Uses the consistent BenchmarkResult shape: ok, step, responses.
+ */
+export function logFailure(
+  benchmarkType: string,
+  result: Partial<BenchmarkResult<unknown>> | null | undefined,
+  options: LogFailureOptions = {}
+): void {
+  const parts: string[] = [`[${benchmarkType}] FAIL`];
+  if (result?.ok === false) {
+    parts.push('result.ok=false');
+  }
+  if (result?.step != null) {
+    parts.push(`step=${result.step}`);
+  }
+  if (result?.responses && typeof result.responses === 'object') {
+    for (const [name, res] of Object.entries(result.responses)) {
+      if (res && typeof res === 'object') {
+        const status = res.status ?? '?';
+        parts.push(`${name}=${status}${res.error ? ` error=${res.error}` : ''}`);
+        if (res.body != null && (res.status == null || res.status >= 400)) {
+          parts.push(`body=${res.body}`);
+        }
+      }
+    }
+  }
+  if (options.extra) {
+    parts.push(options.extra);
+  }
+  console.log(parts.join(' '));
+}

langgraph_api-0.7.91/benchmark/benchmark-runners/meta_workload.ts

@@ -0,0 +1,70 @@
+import { BenchmarkRunner } from './benchmark-runner.js';
+import type { ErrorMetrics } from './benchmark-runner.js';
+import { logFailure } from './log-failure.js';
+import type { BenchmarkResult, BenchmarkGraphOptions } from './types.js';
+import { WaitWrite } from './wait_write.js';
+import { StreamWrite } from './stream_write.js';
+import { Assistant } from './assistant.js';
+import { Thread } from './thread.js';
+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,
+  StreamWrite,
+  Assistant,
+  Thread,
+  EnqueuedRunsOrder,
+  CancelFirstSecondCompletes,
+  ThreadRunsMetadataSearch,
+  ThreadsSearchMetadata,
+  RandomStream,
+];
+
+interface MetaWorkloadData {
+  type: string;
+  result: BenchmarkResult;
+  Runner: typeof BenchmarkRunner;
+}
+
+export class MetaWorkload extends BenchmarkRunner {
+  static run(
+    baseUrl: string,
+    requestParams: Record<string, unknown>,
+    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 ?? {},
+      data: { type: Runner.toString(), result: innerResult, Runner },
+    };
+  }
+
+  static validate(
+    result: BenchmarkResult<MetaWorkloadData>,
+    errorMetrics: ErrorMetrics,
+    benchmarkGraphOptions?: BenchmarkGraphOptions
+  ): boolean {
+    const d = result.data;
+    if (!d) {
+      logFailure(MetaWorkload.toString(), result);
+      errorMetrics.other_errors.add(1);
+      return false;
+    }
+    const success = d.Runner.validate(d.result, errorMetrics, benchmarkGraphOptions);
+    if (!success) {
+      logFailure(MetaWorkload.toString(), result, { extra: `delegated_runner=${d.type}` });
+    }
+    return success;
+  }
+
+  static toString(): string {
+    return 'meta_workload';
+  }
+}