langgraph-api 0.4.36__tar.gz → 0.4.38__tar.gz

{langgraph_api-0.4.36 → langgraph_api-0.4.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.4.36
+Version: 0.4.38
 Author-email: Nuno Campos <nuno@langchain.dev>, Will Fu-Hinthorn <will@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE

langgraph_api-0.4.38/benchmark/Makefile

@@ -0,0 +1,54 @@
+# Benchmark commands
+BASE_URL ?= https://ifh-core-api-dr-benchmark-048d364b548f5d9790082d8ba4fb44d8.us.langgraph.app
+RAMP_START ?= 10
+RAMP_END ?= 1000
+RAMP_MULTIPLIER ?= 2
+WAIT_SECONDS ?= 60
+SUCCESS_THRESHOLD ?= 0.99
+CLEAR_BETWEEN_STEPS ?= true
+CLEAR_DELAY_SECONDS ?= 5
+DATA_SIZE ?= 1000
+DELAY ?= 0
+EXPAND ?= 10
+STEPS ?= 10
+
+benchmark-burst:
+	make benchmark-reset
+	k6 run burst.js
+
+benchmark-ramp:
+	make benchmark-reset
+	k6 run --out json=raw_data_$(shell date +%Y-%m-%dT%H-%M-%S).json ramp.js
+
+benchmark-capacity:
+	rm -f capacity_summary_t*.json capacity_report_*.json capacity_raw_t*.json capacity_hist_*.png capacity_pie_*.png
+	npm install
+	BASE_URL=$(BASE_URL) \
+	RAMP_START=$(RAMP_START) \
+	RAMP_END=$(RAMP_END) \
+	RAMP_MULTIPLIER=$(RAMP_MULTIPLIER) \
+	WAIT_SECONDS=$(WAIT_SECONDS) \
+	SUCCESS_THRESHOLD=$(SUCCESS_THRESHOLD) \
+	CLEAR_BETWEEN_STEPS=$(CLEAR_BETWEEN_STEPS) \
+	CLEAR_DELAY_SECONDS=$(CLEAR_DELAY_SECONDS) \
+	DATA_SIZE=$(DATA_SIZE) \
+	DELAY=$(DELAY) \
+	EXPAND=$(EXPAND) \
+	STEPS=$(STEPS) \
+	node capacity_runner.mjs
+
+benchmark-charts:
+	npm install
+	node graphs.js $(shell ls -t raw_data_*.json | head -1) true
+
+benchmark-reset:
+	node clean.js
+
+benchmark-new-revision:
+	node update-revision.js
+
+benchmark-clean:
+	rm -f results_*.json summary_*.json raw_data_*.json *_chart_*.png
+
+benchmark-clean-charts:
+	rm -f *_chart_*.png

langgraph_api-0.4.38/benchmark/capacity_k6.js

@@ -0,0 +1,221 @@
+import http from 'k6/http';
+import { sleep } from 'k6';
+import { Trend, Counter, Rate } from 'k6/metrics';
+
+// Mao
+
+const baseUrlToBaseUrlName = {
+  'https://ifh-core-api-dr-benchmark-048d364b548f5d9790082d8ba4fb44d8.us.langgraph.app': 'DRC,API S,OPS S,1 Job per',
+  'https://ifh-benchmarks-ba3f7d811fb6564ebe5248bcd7a0a662.us.langgraph.app': 'API S, OPS S, 1 Job per',
+  'https://wfh-benchmark-distributed-r-1603f73b1a175234b9b0fb1f9beea4f1.us.langgraph.app': 'DR,API S,OPS S,1 Job per',
+}
+
+// Metrics
+const runDuration = new Trend('run_duration'); // ms for successful runs
+const runPickUpDuration = new Trend('run_pickup_duration');
+const runReturnDuration = new Trend('run_return_duration');
+const runInsertionDuration = new Trend('run_insertion_duration');
+const runOSSDuration = new Trend('run_oss_duration');
+const successfulRuns = new Counter('successful_runs');
+const failedRuns = new Counter('failed_runs');
+const capacitySuccessRate = new Rate('capacity_success_rate');
+
+// Env
+const BASE_URL = __ENV.BASE_URL;
+const LANGSMITH_API_KEY = __ENV.LANGSMITH_API_KEY;
+
+const TARGET = parseInt(__ENV.TARGET || '10');
+const WAIT_SECONDS = parseInt(__ENV.WAIT_SECONDS || '60');
+const SUCCESS_THRESHOLD = parseFloat(__ENV.SUCCESS_THRESHOLD || '0.99');
+
+// Agent params
+const DATA_SIZE = parseInt(__ENV.DATA_SIZE || '1000');
+const DELAY = parseInt(__ENV.DELAY || '0');
+const EXPAND = parseInt(__ENV.EXPAND || '10');
+const STEPS = parseInt(__ENV.STEPS || '10');
+
+// Options
+export const options = {
+  scenarios: {
+    capacity_single_shot: {
+      executor: 'shared-iterations',
+      vus: TARGET,
+      iterations: TARGET,
+      maxDuration: `${Math.max(WAIT_SECONDS + 120, 150)}s`,
+    },
+  },
+  thresholds: {
+    'capacity_success_rate': [`rate>=${SUCCESS_THRESHOLD}`],
+  },
+};
+
+function headers() {
+  const h = { 'Content-Type': 'application/json' };
+  if (LANGSMITH_API_KEY) h['x-api-key'] = LANGSMITH_API_KEY;
+  return h;
+}
+
+function buildPayload() {
+  return JSON.stringify({
+    assistant_id: 'benchmark',
+    input: {
+      data_size: DATA_SIZE,
+      delay: DELAY,
+      expand: EXPAND,
+      steps: STEPS,
+    },
+    config: {
+      recursion_limit: STEPS + 2,
+    },
+  });
+}
+
+export default function () {
+  // one-shot per iteration: create → wait → poll status once
+  const payload = buildPayload();
+  const reqHeaders = headers();
+
+  let threadId;
+  let runId;
+  let createdAt;
+
+  try {
+    const tRes = http.post(`${BASE_URL}/threads`, payload, {
+      headers: reqHeaders,
+      timeout: '60s',
+    });
+    if (tRes.status !== 200) {
+      failedRuns.add(1);
+      capacitySuccessRate.add(0);
+      return;
+    }
+    const t = tRes.json();
+    threadId = t.thread_id;
+
+    createdAt = new Date().getTime();
+    const rRes = http.post(`${BASE_URL}/threads/${threadId}/runs`, payload, {
+      headers: reqHeaders,
+      timeout: '60s',
+    });
+    if (rRes.status !== 200) {
+      failedRuns.add(1);
+      capacitySuccessRate.add(0);
+      return;
+    }
+    const r = rRes.json();
+    runId = r.run_id;
+  } catch (e) {
+    // Any network error counts as a failure — no retries
+    failedRuns.add(1);
+    capacitySuccessRate.add(0);
+    return;
+  }
+
+  // Sleep the configured wait time, exactly once
+  sleep(WAIT_SECONDS);
+
+  // Poll exactly once
+  try {
+    const gRes = http.get(`${BASE_URL}/threads/${threadId}/runs/${runId}`, {
+      headers: reqHeaders,
+      timeout: '30s',
+    });
+    const tRes = http.get(`${BASE_URL}/threads/${threadId}/state`, {
+      headers: reqHeaders,
+      timeout: '30s',
+    });
+    if (gRes.status !== 200) {
+      failedRuns.add(1);
+      capacitySuccessRate.add(0);
+      return;
+    }
+    const run = gRes.json();
+    const t = tRes.json();
+    if (run.status === 'success') {
+      successfulRuns.add(1);
+      capacitySuccessRate.add(1);
+      try {
+        const insertionMs = new Date(run.created_at).getTime() - createdAt;
+        if (!Number.isNaN(insertionMs) && insertionMs >= 0) {
+          runInsertionDuration.add(insertionMs);
+        }
+        const durMs = new Date(run.updated_at).getTime() - createdAt;
+        if (!Number.isNaN(durMs) && durMs >= 0) {
+          runDuration.add(durMs);
+        }
+        const pickupDurMs = new Date(t.values.start_time).getTime() - new Date(run.created_at).getTime();
+        if (!Number.isNaN(pickupDurMs) && pickupDurMs >= 0) {
+          runPickUpDuration.add(pickupDurMs);
+        }
+        // Note: we are missing the time from `set_joint_status` to actually return to the client (ideally this is negligible)
+        const returnDurMs = new Date(run.updated_at).getTime() - new Date(t.values.end_time).getTime();
+        if (!Number.isNaN(returnDurMs) && returnDurMs >= 0) {
+          runReturnDuration.add(returnDurMs);
+        }
+        const ossDurMs = new Date(t.values.end_time).getTime() - new Date(t.values.start_time).getTime();
+        if (!Number.isNaN(ossDurMs) && ossDurMs >= 0) {
+          runOSSDuration.add(ossDurMs);
+        }
+      } catch (_) {
+        // ignore duration parsing errors
+      }
+    } else {
+      failedRuns.add(1);
+      capacitySuccessRate.add(0);
+    }
+  } catch (e) {
+    failedRuns.add(1);
+    capacitySuccessRate.add(0);
+  }
+}
+
+export function handleSummary(data) {
+  const ts = new Date().toISOString().replace(/:/g, '-').replace(/\..+/, '');
+
+  const total = (data.metrics.successful_runs?.values?.count || 0) + (data.metrics.failed_runs?.values?.count || 0);
+  const succ = data.metrics.successful_runs?.values?.count || 0;
+  const fail = data.metrics.failed_runs?.values?.count || 0;
+  const successRate = total > 0 ? (succ / total) * 100 : 0;
+
+  function withStats(metric) {
+    if (!data.metrics[metric]?.values) return {};
+    const vals = data.metrics[metric].values;
+    return {
+      avg: vals.avg ? vals.avg / 1000 : null,
+      p50: vals.med ? vals.med / 1000 : null,
+      p95: vals['p(95)'] ? vals['p(95)'] / 1000 : null,
+      max: vals.max ? vals.max / 1000 : null,
+    };
+  }
+
+  const summary = {
+    timestamp: ts,
+    settings: {
+      baseUrl: BASE_URL,
+      baseUrlName: baseUrlToBaseUrlName[BASE_URL],
+      target: TARGET,
+      waitSeconds: WAIT_SECONDS,
+      dataSize: DATA_SIZE,
+      delay: DELAY,
+      expand: EXPAND,
+      steps: STEPS,
+    },
+    metrics: {
+      totalRuns: total,
+      successfulRuns: succ,
+      failedRuns: fail,
+      successRate,
+      runDuration: withStats('run_duration'),
+      runPickupDuration: withStats('run_pickup_duration'),
+      runReturnDuration: withStats('run_return_duration'),
+      runInsertionDuration: withStats('run_insertion_duration'),
+      runOSSDuration: withStats('run_oss_duration'),
+    },
+  };
+
+  const fname = `capacity_summary_t${TARGET}_${ts}.json`;
+  return {
+    [fname]: JSON.stringify(summary, null, 2),
+    stdout: JSON.stringify(summary),
+  };
+}

langgraph_api-0.4.38/benchmark/capacity_runner.mjs

@@ -0,0 +1,307 @@
+/*
+ * Adaptive capacity benchmark orchestrator.
+ * Ramps TARGET from RAMP_START up to RAMP_END by RAMP_MULTIPLIER.
+ * For each level N: optional cleanup → run k6 (N users, 1 run each) → wait summary → decide next.
+ * No retries anywhere; errors reduce success rate.
+ */
+
+import { execFileSync } from 'node:child_process';
+import { readdirSync, readFileSync, writeFileSync, createReadStream } from 'node:fs';
+import { join } from 'node:path';
+import readline from 'node:readline';
+import QuickChart from 'quickchart-js';
+
+function envBool(name, def = false) {
+  const v = process.env[name];
+  if (v === undefined || v === null) return def;
+  return String(v).toLowerCase() === 'true';
+}
+
+function envInt(name, def) {
+  const v = process.env[name];
+  if (!v) return def;
+  const n = parseInt(v, 10);
+  return Number.isFinite(n) ? n : def;
+}
+
+function envFloat(name, def) {
+  const v = process.env[name];
+  if (!v) return def;
+  const n = parseFloat(v);
+  return Number.isFinite(n) ? n : def;
+}
+
+const BASE_URL = process.env.BASE_URL;
+const LANGSMITH_API_KEY = process.env.LANGSMITH_API_KEY;
+
+const RAMP_START = envInt('RAMP_START', 10);
+const RAMP_END = envInt('RAMP_END', 1000);
+const RAMP_MULTIPLIER = envFloat('RAMP_MULTIPLIER', 10);
+const WAIT_SECONDS = envInt('WAIT_SECONDS', 60);
+const SUCCESS_THRESHOLD = envFloat('SUCCESS_THRESHOLD', 0.99);
+const CLEAR_BETWEEN_STEPS = envBool('CLEAR_BETWEEN_STEPS', true);
+const CLEAR_DELAY_SECONDS = envInt('CLEAR_DELAY_SECONDS', 5);
+
+// Agent params
+const DATA_SIZE = envInt('DATA_SIZE', 1000);
+const DELAY = envInt('DELAY', 0);
+const EXPAND = envInt('EXPAND', 50);
+const STEPS = envInt('STEPS', 10);
+
+if (!BASE_URL) {
+  console.error('BASE_URL is required');
+  process.exit(1);
+}
+if (!(RAMP_MULTIPLIER > 1)) {
+  console.error('RAMP_MULTIPLIER must be > 1');
+  process.exit(1);
+}
+
+function headers() {
+  const h = { 'Content-Type': 'application/json' };
+  if (LANGSMITH_API_KEY) h['x-api-key'] = LANGSMITH_API_KEY;
+  return h;
+}
+
+async function cleanThreads() {
+  if (!CLEAR_BETWEEN_STEPS) return;
+  const hdrs = headers();
+  const searchUrl = `${BASE_URL}/threads/search`;
+  let totalDeleted = 0;
+  // Loop until no more threads
+  while (true) {
+    const res = await fetch(searchUrl, {
+      method: 'POST',
+      headers: hdrs,
+      body: JSON.stringify({ limit: 1000 }),
+    });
+    if (!res.ok) {
+      console.error(`Cleanup search failed: ${res.status} ${res.statusText}`);
+      break;
+    }
+    const threads = await res.json();
+    if (!Array.isArray(threads) || threads.length === 0) break;
+    for (const t of threads) {
+      try {
+        const del = await fetch(`${BASE_URL}/threads/${t.thread_id}`, {
+          method: 'DELETE',
+          headers: hdrs,
+        });
+        if (del.ok) totalDeleted++;
+      } catch (e) {
+        // Ignore delete errors; do not retry
+      }
+    }
+  }
+  if (CLEAR_DELAY_SECONDS > 0) {
+    await new Promise((r) => setTimeout(r, CLEAR_DELAY_SECONDS * 1000));
+  }
+  console.log(`Cleanup completed. Deleted ~${totalDeleted} threads.`);
+}
+
+function runK6(target) {
+  const env = {
+    ...process.env,
+    BASE_URL,
+    LANGSMITH_API_KEY,
+    TARGET: String(target),
+    WAIT_SECONDS: String(WAIT_SECONDS),
+    SUCCESS_THRESHOLD: String(SUCCESS_THRESHOLD),
+    DATA_SIZE: String(DATA_SIZE),
+    DELAY: String(DELAY),
+    EXPAND: String(EXPAND),
+    STEPS: String(STEPS),
+  };
+  console.log(`Running k6 with TARGET=${target}`);
+  // Also write raw JSON stream for per-stage histograms
+  const ts = new Date().toISOString().replace(/:/g, '-').replace(/\..+/, '');
+  const rawOut = `capacity_raw_t${target}_${ts}.json`;
+  // We rely on handleSummary to write capacity_summary_t${TARGET}_<ts>.json
+  execFileSync('k6', ['run', '--out', `json=${rawOut}`, 'capacity_k6.js'], {
+    cwd: process.cwd(),
+    env,
+    stdio: 'inherit',
+  });
+  return { rawOut, ts };
+}
+
+function loadSummaryForTarget(target) {
+  const files = readdirSync(process.cwd())
+    .filter((f) => f.startsWith(`capacity_summary_t${target}_`) && f.endsWith('.json'))
+    .sort();
+  if (files.length === 0) {
+    throw new Error(`No capacity summary file found for target ${target}`);
+  }
+  const latest = files[files.length - 1];
+  const content = readFileSync(join(process.cwd(), latest), 'utf-8');
+  return JSON.parse(content);
+}
+
+async function main() {
+  let n = RAMP_START;
+  let lastSuccess = null; // { target, avgDurationSeconds, successRate }
+  let failedStep = null; // { target, successRate }
+
+  while (n <= RAMP_END) {
+    console.log(`\n=== Capacity step: N=${n} ===`);
+    if (CLEAR_BETWEEN_STEPS) {
+      console.log('Clearing threads before step...');
+      await cleanThreads();
+    }
+
+    try {
+      const { rawOut, ts } = runK6(n);
+      try {
+        await generateHistogramsForStage(rawOut, n, ts);
+      } catch (e) {
+        console.error(`Failed to generate histograms for N=${n}:`, e?.message || e);
+      }
+    } catch (e) {
+      console.error(`k6 run failed at N=${n}:`, e?.message || e);
+      // Treat as failure for this step
+    }
+
+    let successRate = 0;
+    let avgDurationSeconds = null;
+    try {
+      const summary = loadSummaryForTarget(n);
+      const s = summary?.metrics?.successRate; // percent
+      successRate = Number.isFinite(s) ? s / 100 : 0;
+      avgDurationSeconds = summary?.metrics?.averageDurationSeconds ?? null;
+      console.log(`Step N=${n} successRate=${(successRate * 100).toFixed(2)}% avgDur=${avgDurationSeconds ?? 'n/a'}s`);
+    } catch (e) {
+      console.error(`Failed to read summary for N=${n}:`, e?.message || e);
+    }
+
+    if (successRate >= SUCCESS_THRESHOLD) {
+      lastSuccess = { target: n, avgDurationSeconds, successRate };
+      // next n
+      const next = Math.floor(n * RAMP_MULTIPLIER);
+      if (next <= n) {
+        console.log('Next ramp value would not increase; stopping.');
+        break;
+      }
+      n = next;
+    } else {
+      failedStep = { target: n, successRate };
+      break;
+    }
+  }
+
+  const ts = new Date().toISOString().replace(/:/g, '-').replace(/\..+/, '');
+  const report = {
+    timestamp: ts,
+    ramp: { start: RAMP_START, end: RAMP_END, multiplier: RAMP_MULTIPLIER },
+    waitSeconds: WAIT_SECONDS,
+    threshold: SUCCESS_THRESHOLD,
+    last_success_target: lastSuccess?.target ?? 0,
+    last_success_avg_duration_seconds: lastSuccess?.avgDurationSeconds ?? null,
+    last_success_rate: lastSuccess?.successRate ?? null,
+    failed_target: failedStep?.target ?? null,
+    failed_success_rate: failedStep?.successRate ?? null,
+  };
+  const fname = `capacity_report_${ts}.json`;
+  writeFileSync(join(process.cwd(), fname), JSON.stringify(report, null, 2));
+
+  // Export selected fields as GitHub Action outputs if available
+  if (process.env.GITHUB_OUTPUT) {
+    const out = [
+      `last_success_target=${report.last_success_target}`,
+      `last_success_avg_duration_seconds=${report.last_success_avg_duration_seconds}`,
+      `failed_target=${report.failed_target}`,
+      `failed_success_rate=${report.failed_success_rate}`,
+    ].join('\n');
+    writeFileSync(process.env.GITHUB_OUTPUT, `${out}\n`, { flag: 'a' });
+  }
+
+  console.log('=== Capacity Benchmark Report ===');
+  console.log(`Last successful step: ${report.last_success_target}`);
+  console.log(`Average duration (s) at success: ${report.last_success_avg_duration_seconds}`);
+  console.log(`Failed step: ${report.failed_target} with success rate: ${report.failed_success_rate}`);
+}
+
+main().catch((e) => {
+  console.error('Fatal error in capacity runner:', e?.stack || e?.message || e);
+  process.exit(1);
+});
+
+// Build and save histogram charts for one stage from raw K6 JSON
+async function generateHistogramsForStage(rawFile, target, ts) {
+  // Parse streaming JSONL from k6 --out json
+  const metrics = {
+    run_duration: [],
+    run_pickup_duration: [],
+    run_return_duration: [],
+    run_insertion_duration: [],
+    run_oss_duration: [],
+  };
+
+  await new Promise((resolve, reject) => {
+    const rl = readline.createInterface({ input: createReadStream(join(process.cwd(), rawFile), { encoding: 'utf-8' }), crlfDelay: Infinity });
+    rl.on('line', (line) => {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === 'Point') {
+          const name = entry.metric;
+          if (name in metrics) {
+            const v = entry?.data?.value;
+            if (Number.isFinite(v)) metrics[name].push(v);
+          }
+        }
+      } catch (_) {
+        // ignore parse errors
+      }
+    });
+    rl.on('close', resolve);
+    rl.on('error', reject);
+  });
+
+  // Build pie chart for component breakdown based on average seconds
+  const avg = (arr) => (arr.length ? arr.reduce((a, b) => a + b, 0) / arr.length : 0);
+  const avgInsertionS = avg(metrics.run_insertion_duration) / 1000;
+  const avgPickupS = avg(metrics.run_pickup_duration) / 1000;
+  const avgOssS = avg(metrics.run_oss_duration) / 1000;
+  const avgReturnS = avg(metrics.run_return_duration) / 1000;
+  const parts = [avgInsertionS, avgPickupS, avgOssS, avgReturnS];
+  const totalParts = parts.reduce((a, b) => a + b, 0);
+  if (totalParts > 0) {
+    const chart = new QuickChart();
+    chart.setWidth(700);
+    chart.setHeight(500);
+    chart.setFormat('png');
+    chart.setConfig({
+      type: 'pie',
+      data: {
+        labels: ['Insertion', 'Pickup', 'OSS', 'Return'],
+        datasets: [{
+          label: `Breakdown of Run Duration (N=${target})`,
+          data: parts.map((v) => Number(v.toFixed(4))),
+          backgroundColor: [
+            'rgba(255, 99, 132, 0.6)',
+            'rgba(54, 162, 235, 0.6)',
+            'rgba(255, 206, 86, 0.6)',
+            'rgba(75, 192, 192, 0.6)',
+          ],
+          borderColor: [
+            'rgba(255, 99, 132, 1)',
+            'rgba(54, 162, 235, 1)',
+            'rgba(255, 206, 86, 1)',
+            'rgba(75, 192, 192, 1)',
+          ],
+          borderWidth: 1,
+        }],
+      },
+      options: {
+        plugins: {
+          title: { display: true, text: `Run Duration Breakdown (s) — N=${target}` },
+          legend: { position: 'right' },
+          tooltip: { callbacks: { label: (ctx) => `${ctx.label}: ${ctx.parsed.toFixed(3)}s` } },
+        },
+      },
+    });
+    const pieBuf = await chart.toBinary();
+    const piePath = join(process.cwd(), `capacity_pie_breakdown_t${target}_${ts}.png`);
+    writeFileSync(piePath, pieBuf);
+    console.log(`Saved pie chart: ${piePath}`);
+  }
+}

langgraph_api-0.4.38/benchmark/reporting/dd_reporting.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""
+Parse benchmark JSON results and send to Datadog.
+Install: pip install datadog-api-client
+"""
+
+import argparse
+import glob
+import json
+import os
+import sys
+
+from datadog_api_client import ApiClient, Configuration
+from datadog_api_client.v2.api.logs_api import LogsApi
+from datadog_api_client.v2.model.http_log import HTTPLog
+from datadog_api_client.v2.model.http_log_item import HTTPLogItem
+
+
+def send_benchmark_results(
+    benchmark_data, common_labels=None, dd_site="us5.datadoghq.com", api_key=None
+):
+    """
+    Send benchmark JSON to Datadog.
+
+    Args:
+        benchmark_data: Dict containing 'settings' and 'metrics' from benchmark
+        common_labels: Additional labels (e.g., base_url)
+    """
+    configuration = Configuration()
+    configuration.server_variables["site"] = dd_site
+    configuration.api_key["apiKeyAuth"] = api_key
+
+    if common_labels:
+        benchmark_data["labels"] = common_labels
+
+    log_item = HTTPLogItem(
+        ddsource="benchmark",
+        ddtags=f"env:benchmarking,base_url:{common_labels.get('base_url', 'unknown')}"
+        if common_labels
+        else "env:benchmarking",
+        hostname=os.getenv("HOSTNAME", "localhost"),
+        message=json.dumps(benchmark_data),
+        service="benchmark-results",
+    )
+
+    with ApiClient(configuration) as api_client:
+        api_instance = LogsApi(api_client)
+        body = HTTPLog([log_item])
+
+        api_instance.submit_log(body=body)
+
+
+def process_benchmark_file(
+    json_file, common_labels=None, dd_site="us5.datadoghq.com", api_key=None
+):
+    """
+    Read benchmark JSON file and send to Datadog.
+
+    Args:
+        json_file: Path to benchmark results JSON file
+        common_labels: Additional labels for all metrics
+    """
+    with open(json_file) as f:
+        data = json.load(f)
+
+    send_benchmark_results(data, common_labels, dd_site, api_key)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Send benchmark results to Datadog")
+    parser.add_argument(
+        "benchmark_file", type=str, help="Path to benchmark results file"
+    )
+    args = parser.parse_args()
+
+    DD_API_KEY = os.getenv("DD_API_KEY")
+    if not DD_API_KEY:
+        sys.exit(1)
+
+    DD_SITE = os.getenv("DD_SITE", "us5.datadoghq.com")
+
+    common_labels = {"base_url": os.getenv("BASE_URL")}
+
+    for file in glob.glob(args.benchmark_file):
+        process_benchmark_file(file, common_labels, DD_SITE, DD_API_KEY)

langgraph_api-0.4.38/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.38"

{langgraph_api-0.4.36 → langgraph_api-0.4.38}/langgraph_api/api/meta.py

@@ -24,7 +24,8 @@ async def meta_info(request: ApiRequest):
             "flags": {
                 "assistants": True,
                 "crons": plus and config.FF_CRONS_ENABLED,
-                "langsmith": bool(config.LANGSMITH_API_KEY) and bool(config.TRACING),
+                "langsmith": bool(config.LANGSMITH_CONTROL_PLANE_API_KEY)
+                and bool(config.TRACING),
                 "langsmith_tracing_replicas": True,
             },
             "host": {