langgraph-api 0.14.0.dev4__tar.gz → 0.14.0.dev5__tar.gz

{langgraph_api-0.14.0.dev4 → langgraph_api-0.14.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.14.0.dev4
+Version: 0.14.0.dev5
 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.14.0.dev4 → langgraph_api-0.14.0.dev5}/benchmark/Makefile

@@ -19,6 +19,14 @@ benchmark-new-revision:
 benchmark-staircase:
 	python staircase.py
 
+benchmark-capacity-ci:
+	npm install
+	node capacity-ci.js
+
+benchmark-capacity-matrix:
+	npm install
+	node capacity-ci.js --all-deployments
+
 benchmark-staircase-reset:
 	python ../../scripts/reset_deployment.py -a $(BENCHMARK_APP_NAME) -n $(BENCHMARK_NAMESPACE) -db $(BENCHMARK_DB_INSTANCE)
 	python staircase.py

{langgraph_api-0.14.0.dev4 → langgraph_api-0.14.0.dev5}/benchmark/README.md

@@ -25,6 +25,14 @@ This directory contains k6 + Python/Node benchmark tooling for LangGraph API.
 - `make benchmark-reset` - Cleans benchmark server state via `clean-cli.js`.
 - `make benchmark-new-revision` - Triggers a new benchmark deployment revision.
 
+- `make benchmark-capacity-ci` - Runs the daily capacity matrix for one deployment (`DEPLOYMENT` env). Uses `staircase.py` per cell (default 200–2000 VUs, step 100). Config lives in `capacity-ci.js`.
+  - **Example:**
+    - `DEPLOYMENT=daily-cap-benchmark-dedicated make benchmark-capacity-ci`
+
+- `make benchmark-capacity-matrix` - Runs the full local capacity matrix for all deployments in `capacity-ci.js` (sequential).
+
+Host API calls use [`host-v2.js`](host-v2.js) (v2 revisions + resource-tiers). [`update-revision.js`](update-revision.js) uses the same module.
+
 ## 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:
@@ -113,11 +121,32 @@ make benchmark-clean
   - `summary_<timestamp>.json`
   - `*_chart_*.png` (when chart generation is run)
 - Staircase:
-  - `staircase_summary.json`
+  - `staircase_summary.json` (or `SUMMARY_PATH` when set by capacity CI)
+  - `staircase_summary_<deployment>_<tier>_<runner>.json` (capacity matrix)
 
 ## CI workflows
 
 - Daily ramp benchmark: `.github/workflows/benchmark.yml`
+- Daily capacity matrix: `.github/workflows/benchmark-capacity-matrix.yml`
+
+### Capacity matrix setup
+
+1. Create staging deployments `daily-cap-benchmark-dedicated` and `daily-cap-benchmark-serverless`.
+2. Fill in `deploymentId` and `baseUrl` in `CAPACITY_DEPLOYMENTS` at the top of [`capacity-ci.js`](capacity-ci.js).
+3. Scheduled run: two parallel CI jobs (one per deployment), aggregate job posts Slack summary.
+
+Local commands:
+
+```bash
+# Single deployment (9 cells: 3 tiers × 3 runners)
+DEPLOYMENT=daily-cap-benchmark-dedicated make benchmark-capacity-ci
+
+# All deployments sequentially (18 cells)
+make benchmark-capacity-matrix
+
+# Aggregate downloaded CI artifacts
+node capacity-ci.js --aggregate --summaries-dir ./artifacts --slack
+```
 
 ## References
 

langgraph_api-0.14.0.dev5/benchmark/capacity-ci.js

@@ -0,0 +1,332 @@
+/**
+ * Daily capacity benchmark orchestrator.
+ *
+ * Usage:
+ *   DEPLOYMENT=daily-cap-benchmark-dedicated node capacity-ci.js
+ *   node capacity-ci.js --all-deployments
+ *   node capacity-ci.js --aggregate --summaries-dir ./artifacts --slack
+ */
+
+import { spawnSync } from "node:child_process";
+import { readdirSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { requireApiKey, setResourceTiers } from "./host-v2.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/** @type {Array<{slug: string, deploymentId: string, baseUrl: string, tiers: string[]}>} */
+const CAPACITY_DEPLOYMENTS = [
+  {
+    slug: "daily-cap-benchmark-dedicated",
+    deploymentId: "22a22e9d-521e-4635-9bcb-a096a22820cc",
+    baseUrl:
+      "https://daily-cap-benchmark-dedicat-9669b63626045e0681f1f1fda08ef4ce.staging.langgraph.app",
+    tiers: ["DEDICATED_L", "DEDICATED_M", "DEDICATED_S"],
+  },
+  {
+    slug: "daily-cap-benchmark-serverless",
+    deploymentId: "becfa8bb-e2e3-4d96-8d08-3191b17c5d4d",
+    baseUrl:
+      "https://daily-cap-benchmark-serverl-b5dc9d9f7fa05990b279939863ae08de.staging.langgraph.app",
+    tiers: ["SERVERLESS_L", "SERVERLESS_M", "SERVERLESS_S"],
+  },
+];
+
+const RUNNERS = ["wait_write", "stream_write", "threads_search_metadata"];
+
+const RUNNER_LABELS = {
+  wait_write: "wait_write",
+  stream_write: "stream_write",
+  threads_search_metadata: "threads_search",
+};
+
+// 200 + 100 * (19 - 1) = 2000 VUs
+const STAIRCASE_START_LOAD = "200";
+const STAIRCASE_STEP_SIZE = "100";
+const STAIRCASE_NUM_STEPS = "19";
+
+function validateDeployment(deployment) {
+  const missing = [];
+  if (!deployment.slug) missing.push("slug");
+  if (!deployment.deploymentId) missing.push("deploymentId");
+  if (!deployment.baseUrl) missing.push("baseUrl");
+  if (!deployment.tiers?.length) missing.push("tiers");
+  if (missing.length > 0) {
+    throw new Error(
+      `Deployment ${deployment.slug || "<unknown>"} is missing required fields: ${missing.join(", ")}. ` +
+        "Update CAPACITY_DEPLOYMENTS in capacity-ci.js.",
+    );
+  }
+}
+
+function getDeployment(slug, deployments = CAPACITY_DEPLOYMENTS) {
+  const deployment = deployments.find((entry) => entry.slug === slug);
+  if (!deployment) {
+    const known = deployments.map((entry) => entry.slug).join(", ");
+    throw new Error(
+      `Unknown deployment ${JSON.stringify(slug)}. Known deployments: ${known}`,
+    );
+  }
+  return deployment;
+}
+
+function capacityVus(summary) {
+  if (!summary?.capacity) return "-";
+  return String(summary.capacity.targetVUs ?? "-");
+}
+
+function formatAggregateTable(deployments, summaries) {
+  /** @type {Record<string, Record<string, Record<string, object>>>} */
+  const byDeployment = Object.fromEntries(deployments.map((d) => [d.slug, {}]));
+
+  for (const summary of summaries) {
+    const config = summary.config ?? {};
+    const { deploymentSlug, computeTier, benchmarkType } = config;
+    if (deploymentSlug && computeTier && benchmarkType) {
+      byDeployment[deploymentSlug] ??= {};
+      byDeployment[deploymentSlug][computeTier] ??= {};
+      byDeployment[deploymentSlug][computeTier][benchmarkType] = summary;
+    }
+  }
+
+  const lines = ["*Daily Capacity Benchmark* (stable, default profile)", ""];
+  for (const deployment of deployments) {
+    lines.push(`*${deployment.slug}*`);
+    lines.push(
+      `${"".padEnd(16)}${RUNNERS.map((runner) => RUNNER_LABELS[runner].padEnd(16)).join("")}`,
+    );
+    for (const tier of deployment.tiers) {
+      let row = tier.padEnd(16);
+      for (const runner of RUNNERS) {
+        const summary = byDeployment[deployment.slug]?.[tier]?.[runner];
+        row += capacityVus(summary).padEnd(16);
+      }
+      lines.push(row);
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+
+function summaryPathFor(deploymentSlug, tier, runner) {
+  const safeTier = tier.replaceAll("/", "-");
+  return path.join(
+    __dirname,
+    `staircase_summary_${deploymentSlug}_${safeTier}_${runner}.json`,
+  );
+}
+
+function runCommand(command, args, env) {
+  const result = spawnSync(command, args, {
+    cwd: __dirname,
+    env: { ...process.env, ...env },
+    stdio: "inherit",
+  });
+  if (result.status !== 0) {
+    throw new Error(
+      `${command} ${args.join(" ")} failed with exit code ${result.status}`,
+    );
+  }
+}
+
+function ensureBuild() {
+  runCommand("npm", ["run", "build"], {});
+}
+
+function runReset(baseUrl, apiKey) {
+  runCommand("node", ["clean-cli.js"], {
+    BASE_URL: baseUrl,
+    LANGSMITH_API_KEY: apiKey,
+  });
+}
+
+function runStaircase({
+  baseUrl,
+  apiKey,
+  runner,
+  deploymentSlug,
+  computeTier,
+  summaryPath,
+}) {
+  runCommand(process.env.PYTHON || "python3", ["staircase.py"], {
+    BASE_URL: baseUrl,
+    LANGSMITH_API_KEY: apiKey,
+    BENCHMARK_TYPE: runner,
+    DEPLOYMENT_SLUG: deploymentSlug,
+    COMPUTE_TIER: computeTier,
+    SUMMARY_PATH: summaryPath,
+    START_LOAD: process.env.START_LOAD || STAIRCASE_START_LOAD,
+    STEP_SIZE: process.env.STEP_SIZE || STAIRCASE_STEP_SIZE,
+    NUM_STEPS: process.env.NUM_STEPS || STAIRCASE_NUM_STEPS,
+  });
+}
+
+function printDeploymentTable(deployment, summaryPaths) {
+  /** @type {Record<string, Record<string, object>>} */
+  const byKey = {};
+  for (const summaryPath of summaryPaths) {
+    const summary = JSON.parse(readFileSync(summaryPath, "utf8"));
+    const config = summary.config ?? {};
+    byKey[`${config.computeTier}:${config.benchmarkType}`] = summary;
+  }
+
+  const header =
+    "tier".padEnd(16) +
+    RUNNERS.map((runner) => RUNNER_LABELS[runner].padEnd(16)).join("");
+  console.log(
+    `\nCapacity results — ${deployment.slug} (max VUs @ SLO)\n${header}`,
+  );
+  for (const tier of deployment.tiers) {
+    let row = tier.padEnd(16);
+    for (const runner of RUNNERS) {
+      const summary = byKey[`${tier}:${runner}`];
+      row += capacityVus(summary).padEnd(16);
+    }
+    console.log(row);
+  }
+}
+
+async function runDeploymentMatrix(deployment, apiKey) {
+  console.log(
+    `\n${"=".repeat(80)}\nCapacity matrix: ${deployment.slug}\n${"=".repeat(80)}`,
+  );
+  validateDeployment(deployment);
+
+  /** @type {string[]} */
+  const summaryPaths = [];
+  for (const tier of deployment.tiers) {
+    console.log(`\n--- Tier ${tier} ---`);
+    const databaseTier = tier.startsWith("DEDICATED_") ? tier : undefined;
+    await setResourceTiers(
+      deployment.deploymentId,
+      tier,
+      databaseTier,
+      apiKey,
+      deployment.baseUrl,
+    );
+    for (const runner of RUNNERS) {
+      const summaryPath = summaryPathFor(deployment.slug, tier, runner);
+      console.log(`\n>> ${deployment.slug} / ${tier} / ${runner}`);
+      runReset(deployment.baseUrl, apiKey);
+      runStaircase({
+        baseUrl: deployment.baseUrl,
+        apiKey,
+        runner,
+        deploymentSlug: deployment.slug,
+        computeTier: tier,
+        summaryPath,
+      });
+      summaryPaths.push(summaryPath);
+    }
+  }
+
+  printDeploymentTable(deployment, summaryPaths);
+  return summaryPaths;
+}
+
+function collectSummaries(directory) {
+  const paths = readdirSync(directory)
+    .filter(
+      (name) => name.startsWith("staircase_summary_") && name.endsWith(".json"),
+    )
+    .sort()
+    .map((name) => path.join(directory, name));
+  if (paths.length === 0) {
+    throw new Error(`No staircase_summary_*.json files found in ${directory}`);
+  }
+  return paths.map((summaryPath) =>
+    JSON.parse(readFileSync(summaryPath, "utf8")),
+  );
+}
+
+async function postSlack(message) {
+  const token = process.env.SLACK_BOT_TOKEN;
+  const channel = process.env.SLACK_CHANNEL;
+  if (!token || !channel) {
+    console.log(
+      "SLACK_BOT_TOKEN or SLACK_CHANNEL not set; skipping Slack post",
+    );
+    console.log(message);
+    return;
+  }
+
+  const response = await fetch("https://slack.com/api/chat.postMessage", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json; charset=utf-8",
+      Authorization: `Bearer ${token}`,
+    },
+    body: JSON.stringify({ channel, text: message }),
+  });
+  const result = await response.json();
+  if (!result.ok) {
+    throw new Error(`Slack API error: ${result.error ?? "unknown"}`);
+  }
+  console.log("Posted aggregate summary to Slack");
+}
+
+async function runAggregate(summariesDir, { postToSlack }) {
+  const summaries = collectSummaries(summariesDir);
+  const message = formatAggregateTable(CAPACITY_DEPLOYMENTS, summaries);
+  console.log(message);
+  if (postToSlack) {
+    const artifactUrl = process.env.GITHUB_RUN_URL;
+    const slackMessage = artifactUrl
+      ? `${message}\n\n<${artifactUrl}|Download artifacts>`
+      : message;
+    await postSlack(slackMessage);
+  }
+}
+
+function parseArgs(argv) {
+  return {
+    allDeployments: argv.includes("--all-deployments"),
+    aggregate: argv.includes("--aggregate"),
+    slack: argv.includes("--slack"),
+    summariesDir:
+      argv.includes("--summaries-dir") &&
+      argv[argv.indexOf("--summaries-dir") + 1]
+        ? path.resolve(argv[argv.indexOf("--summaries-dir") + 1])
+        : __dirname,
+  };
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.aggregate) {
+    await runAggregate(args.summariesDir, { postToSlack: args.slack });
+    return;
+  }
+
+  const apiKey = requireApiKey();
+  if (args.allDeployments) {
+    ensureBuild();
+    for (const deployment of CAPACITY_DEPLOYMENTS) {
+      await runDeploymentMatrix(deployment, apiKey);
+    }
+    return;
+  }
+
+  const slug = process.env.DEPLOYMENT;
+  if (!slug) {
+    console.error(
+      "Set DEPLOYMENT to a slug from CAPACITY_DEPLOYMENTS in capacity-ci.js, or pass --all-deployments",
+    );
+    process.exit(1);
+  }
+
+  ensureBuild();
+  await runDeploymentMatrix(getDeployment(slug), apiKey);
+}
+
+const isMain =
+  process.argv[1] &&
+  path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  main().catch((error) => {
+    console.error(error.message);
+    process.exit(1);
+  });
+}

langgraph_api-0.14.0.dev5/benchmark/host-v2.js

@@ -0,0 +1,227 @@
+/**
+ * LangSmith Host v2 API helpers for benchmark tooling.
+ */
+
+export const STAGING_TENANT_ID = '8f32dc68-61a1-439c-81d3-33511ef55527';
+export const HOST_V2_BASE =
+  process.env.HOST_API_V2_BASE || 'https://beta.api.host.langchain.com/v2';
+
+export const REVISION_CONFIG = {
+  source_revision_config: {
+    langgraph_config_path: 'langgraph.json',
+  },
+};
+
+export const EXPECTED_REVISION_STATUSES = new Set([
+  'CREATING',
+  'QUEUED',
+  'AWAITING_BUILD',
+  'BUILDING',
+  'AWAITING_DEPLOY',
+  'DEPLOYING',
+  'DEPLOYED',
+]);
+
+export const FINAL_REVISION_STATUS = 'DEPLOYED';
+export const POLL_INTERVAL_MS = 10_000;
+export const MAX_WAIT_MS = 30 * 60 * 1000;
+
+export function requireApiKey() {
+  const apiKey = process.env.LANGSMITH_API_KEY;
+  if (!apiKey) {
+    throw new Error('LANGSMITH_API_KEY environment variable is required');
+  }
+  return apiKey;
+}
+
+export function hostHeaders(apiKey) {
+  return {
+    'Content-Type': 'application/json',
+    'x-api-key': apiKey,
+    'X-Tenant-Id': STAGING_TENANT_ID,
+    'X-Organization-Id': STAGING_TENANT_ID,
+  };
+}
+
+async function readErrorDetail(response) {
+  try {
+    return await response.text();
+  } catch {
+    return response.statusText;
+  }
+}
+
+export async function hostRequest(method, path, apiKey, body) {
+  const response = await fetch(`${HOST_V2_BASE}${path}`, {
+    method,
+    headers: hostHeaders(apiKey),
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  if (!response.ok) {
+    const detail = await readErrorDetail(response);
+    throw new Error(`${method} ${path} failed: ${response.status} ${detail}`);
+  }
+  if (response.status === 204) {
+    return null;
+  }
+  return response.json();
+}
+
+export async function listLatestRevision(deploymentId, apiKey) {
+  const result = await hostRequest(
+    'GET',
+    `/deployments/${deploymentId}/revisions?limit=1&offset=0`,
+    apiKey,
+  );
+  const revisions = result?.resources ?? [];
+  if (revisions.length === 0) {
+    throw new Error(`No revisions found for deployment ${deploymentId}`);
+  }
+  return revisions[0];
+}
+
+export async function pollRevisionDeployed(deploymentId, apiKey) {
+  const startTime = Date.now();
+  let lastStatus = null;
+
+  while (true) {
+    let revision;
+    try {
+      revision = await listLatestRevision(deploymentId, apiKey);
+    } catch (error) {
+      if (Date.now() - startTime > MAX_WAIT_MS) {
+        throw new Error(
+          `Deployment timeout after ${MAX_WAIT_MS / 60000} minutes. Last error: ${error.message}`,
+        );
+      }
+      console.error('Error polling revision (will retry):', error.message);
+      await sleep(POLL_INTERVAL_MS);
+      continue;
+    }
+
+    const currentStatus = revision.status;
+    if (currentStatus !== lastStatus) {
+      console.log(`[${new Date().toISOString()}] revision status: ${currentStatus}`);
+      lastStatus = currentStatus;
+    }
+
+    if (currentStatus === FINAL_REVISION_STATUS) {
+      console.log('  revision deployed');
+      return revision;
+    }
+
+    if (!EXPECTED_REVISION_STATUSES.has(currentStatus)) {
+      throw new Error(`Deployment failed with status: ${currentStatus}`);
+    }
+
+    if (Date.now() - startTime > MAX_WAIT_MS) {
+      throw new Error(
+        `Deployment timeout after ${MAX_WAIT_MS / 60000} minutes. Last status: ${currentStatus}`,
+      );
+    }
+
+    await sleep(POLL_INTERVAL_MS);
+  }
+}
+
+export async function createRevision(deploymentId, apiKey) {
+  console.log(`Triggering new revision for deployment ${deploymentId}...`);
+  const response = await fetch(`${HOST_V2_BASE}/deployments/${deploymentId}/revisions`, {
+    method: 'POST',
+    headers: hostHeaders(apiKey),
+    body: JSON.stringify(REVISION_CONFIG),
+  });
+  if (response.status === 409) {
+    console.log('  revision already in progress; polling existing deployment...');
+  } else if (!response.ok) {
+    const detail = await readErrorDetail(response);
+    throw new Error(
+      `POST /deployments/${deploymentId}/revisions failed: ${response.status} ${detail}`,
+    );
+  } else {
+    const revision = await response.json();
+    console.log(`  revision created: ${revision.id} (${revision.status})`);
+  }
+  return pollRevisionDeployed(deploymentId, apiKey);
+}
+
+export async function pollDeploymentHealthy(baseUrl, apiKey, { checkDb = true } = {}) {
+  const url = new URL('ok', baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`);
+  if (checkDb) {
+    url.searchParams.set('check_db', '1');
+  }
+
+  const startTime = Date.now();
+  let lastError = 'unknown';
+
+  console.log(`Polling deployment health at ${url}...`);
+
+  while (true) {
+    try {
+      const headers = { Accept: 'application/json' };
+      if (apiKey) {
+        headers['x-api-key'] = apiKey;
+      }
+      const response = await fetch(url, { headers });
+      if (response.ok) {
+        const body = await response.json();
+        if (body?.ok === true) {
+          console.log('  deployment health check passed');
+          return;
+        }
+        lastError = `unexpected body: ${JSON.stringify(body)}`;
+      } else {
+        const detail = await readErrorDetail(response);
+        lastError = `HTTP ${response.status} ${detail}`;
+      }
+    } catch (error) {
+      lastError = error.message;
+    }
+
+    if (Date.now() - startTime > MAX_WAIT_MS) {
+      throw new Error(
+        `Health check timeout after ${MAX_WAIT_MS / 60000} minutes. Last error: ${lastError}`,
+      );
+    }
+
+    console.log(`  health check pending (${lastError})`);
+    await sleep(POLL_INTERVAL_MS);
+  }
+}
+
+export async function setResourceTiers(
+  deploymentId,
+  computeTier,
+  databaseTier,
+  apiKey,
+  baseUrl,
+) {
+  /** @type {{ compute_tier?: string, database_tier?: string }} */
+  const body = {};
+  if (computeTier != null) {
+    body.compute_tier = computeTier;
+  }
+  if (databaseTier != null) {
+    body.database_tier = databaseTier;
+  }
+  if (Object.keys(body).length === 0) {
+    throw new Error('At least one of computeTier or databaseTier is required');
+  }
+  console.log(
+    `Setting resource tiers for deployment ${deploymentId}: ${JSON.stringify(body)}`,
+  );
+  await hostRequest(
+    'PATCH',
+    `/deployments/${deploymentId}/resource-tiers`,
+    apiKey,
+    body,
+  );
+  await pollRevisionDeployed(deploymentId, apiKey);
+  if (databaseTier != null && baseUrl) {
+    await pollDeploymentHealthy(baseUrl, apiKey, { checkDb: true });
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

{langgraph_api-0.14.0.dev4 → langgraph_api-0.14.0.dev5}/benchmark/staircase.py

@@ -36,6 +36,9 @@ Environment variables:
 
     BENCHMARK_TYPE        Benchmark runner type (default: wait_write)
     BENCHMARK_PROFILE     Optional profile override (e.g. etsy, metaview)
+    DEPLOYMENT_SLUG       Deployment slug for capacity CI metadata (optional)
+    COMPUTE_TIER          Compute tier for capacity CI metadata (optional)
+    SUMMARY_PATH          Output path for summary JSON (default: staircase_summary.json)
     RUN_MODE              stateless (default) or stateful
     DATA_SIZE, DELAY, EXPAND, STEPS, MODE — agent parameters
 """
@@ -65,6 +68,12 @@ MAX_P50_DURATION_MS = int(os.environ.get("MAX_P50_DURATION_MS", "3000"))
 MAX_P95_DURATION_MS = int(os.environ.get("MAX_P95_DURATION_MS", "10000"))
 ABORT_ERROR_RATE = float(os.environ.get("ABORT_ERROR_RATE", "10"))
 
+BENCHMARK_TYPE = os.environ.get("BENCHMARK_TYPE", "wait_write")
+BENCHMARK_PROFILE = os.environ.get("BENCHMARK_PROFILE", "default")
+DEPLOYMENT_SLUG = os.environ.get("DEPLOYMENT_SLUG", "")
+COMPUTE_TIER = os.environ.get("COMPUTE_TIER", "")
+SUMMARY_PATH = os.environ.get("SUMMARY_PATH", "staircase_summary.json")
+
 K6_SCRIPT = Path(__file__).parent / "staircase_step_k6.js"
 
 
@@ -302,11 +311,15 @@ def main():
             "maxP95DurationMs": MAX_P95_DURATION_MS,
             "abortErrorRate": ABORT_ERROR_RATE,
             "baseUrl": BASE_URL,
+            "benchmarkType": BENCHMARK_TYPE,
+            "benchmarkProfile": BENCHMARK_PROFILE,
+            "deploymentSlug": DEPLOYMENT_SLUG or None,
+            "computeTier": COMPUTE_TIER or None,
         },
         "steps": steps,
     }
-    Path("staircase_summary.json").write_text(json.dumps(summary, indent=2))
-    print("\nResults written to staircase_summary.json")
+    Path(SUMMARY_PATH).write_text(json.dumps(summary, indent=2))
+    print(f"\nResults written to {SUMMARY_PATH}")
 
 
 if __name__ == "__main__":

langgraph_api-0.14.0.dev5/benchmark/update-revision.js

@@ -0,0 +1,20 @@
+/*
+ * Trigger a new revision deployment and wait for it to complete.
+ * Uses Host v2 deployment APIs.
+ */
+
+import { createRevision, requireApiKey } from './host-v2.js';
+
+const DEPLOYMENT_ID =
+  process.env.DEPLOYMENT_ID || '03b7336a-73dd-4ee5-8b5e-da19c48a6cdc';
+
+async function updateRevision() {
+  const apiKey = requireApiKey();
+  await createRevision(DEPLOYMENT_ID, apiKey);
+  console.log('\n✓ Deployment completed successfully!');
+}
+
+updateRevision().catch((error) => {
+  console.error('Fatal error during revision update:', error.message);
+  process.exit(1);
+});

langgraph_api-0.14.0.dev5/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.14.0.dev5"