@langwatch/mcp-server 2.0.0 → 2.2.0

package/dist/{chunk-4QC7SA2L.js → chunk-J7PQKBLD.js}

@@ -1,98 +1,50 @@
+import {
+  SLACK_DELIVERY_NOTE,
+  TRIGGER_FILTERS_DESCRIPTION,
+  TRIGGER_FILTER_QUERY_DESCRIPTION,
+  actionParamsSchema,
+  alertTypeSchema,
+  graphAlertSchema,
+  notificationCadenceSchema,
+  reportSchema,
+  templatesSchema,
+  triggerActionSchema,
+  validateActionParamsForAction
+} from "./chunk-3YLN3ATJ.js";
+import {
+  testAgent
+} from "./chunk-HGELNIVY.js";
+import {
+  runParametersSchema,
+  runPlanScopeSchema,
+  runPlanTargetSchema
+} from "./chunk-O7EMWEVJ.js";
+import {
+  evaluatorAttachmentsSchema,
+  scenarioFieldValuesSchema,
+  suiteFieldsSchema,
+  toWireAttachments
+} from "./chunk-U24EACC4.js";
+import {
+  formatEvaluatorAttachments,
+  formatSuiteFields
+} from "./chunk-6YZUOD34.js";
+import {
+  updateTestSuite
+} from "./chunk-VMWJD732.js";
 import {
   LangWatchApiError,
-  makeRequest
-} from "./chunk-A2LEVYQ5.js";
+  makeRequest,
+  package_default
+} from "./chunk-UWLE5T2F.js";
 import {
   requireApiKey
-} from "./chunk-WT4PO4A3.js";
+} from "./chunk-H6WGMG2T.js";
 
 // src/create-mcp-server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z as z2 } from "zod";
 
-// package.json
-var package_default = {
-  name: "@langwatch/mcp-server",
-  version: "2.0.0",
-  description: "An MCP server for Langwatch.",
-  type: "module",
-  main: "./dist/index.js",
-  module: "./dist/index.js",
-  types: "./dist/index.d.ts",
-  exports: {
-    ".": {
-      import: "./dist/index.js",
-      require: "./dist/index.js"
-    },
-    "./create-mcp-server": {
-      types: "./src/create-mcp-server.d.ts",
-      import: "./dist/create-mcp-server.js",
-      require: "./dist/create-mcp-server.js",
-      default: "./dist/create-mcp-server.js"
-    },
-    "./config": {
-      types: "./src/config.d.ts",
-      import: "./dist/config.js",
-      require: "./dist/config.js",
-      default: "./dist/config.js"
-    }
-  },
-  repository: {
-    type: "git",
-    url: "https://github.com/langwatch/langwatch.git",
-    directory: "mcp-server"
-  },
-  scripts: {
-    start: "tsx src/index.ts",
-    build: "tsup && node build.js",
-    prepublish: "pnpm run build",
-    test: "vitest"
-  },
-  author: "",
-  license: "MIT",
-  engines: {
-    node: ">=18.0.0"
-  },
-  devDependencies: {
-    "@ai-sdk/anthropic": "^3.0.44",
-    "@anthropic-ai/claude-code": "2.1.202",
-    "@eslint/js": "^10.0.1",
-    "@langwatch/handled-error": "workspace:*",
-    "@langwatch/redaction": "workspace:*",
-    "@langwatch/scenario": "^0.4.6",
-    "@langwatch/ssrf": "workspace:*",
-    "@opentelemetry/context-async-hooks": "^2.1.0",
-    "@opentelemetry/sdk-node": "^0.219.0",
-    "@types/debug": "^4.1.13",
-    "@types/express": "^5.0.6",
-    "@types/node": "^25.6.0",
-    "@types/yargs": "^17.0.33",
-    "@typescript/native-preview": "7.0.0-dev.20260705.1",
-    ai: "^6.0.161",
-    chalk: "^5.6.2",
-    "date-fns": "^4.1.0",
-    dotenv: "^17.2.2",
-    esbuild: "^0.28.1",
-    eslint: "^10.2.1",
-    express: "^5.2.1",
-    "node-pty": "^1.0.0",
-    tsup: "^8.1.0",
-    tsx: "^4.20.5",
-    typescript: "^5.0.0",
-    "typescript-eslint": "^8.55.0",
-    vitest: "^4.1.8",
-    yargs: "^18.0.0",
-    "zod-validation-error": "^5.0.0"
-  },
-  dependencies: {
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    zod: "^4.3.6"
-  },
-  bin: {
-    "langwatch-mcp-server": "./dist/index.js"
-  }
-};
-
 // src/documentation-fetch.ts
 var TRUSTED_DOCUMENTATION_ORIGIN = "https://langwatch.ai";
 var MAX_DOCUMENTATION_BYTES = 2 * 1024 * 1024;
@@ -131,7 +83,8 @@ function resolveDocumentationUrl(kind, input) {
   } catch {
     throw documentationUrlError(namespace);
   }
-  if (url.protocol !== "https:" || url.hostname !== "langwatch.ai" || url.port !== "" || url.username !== "" || url.password !== "" || !url.pathname.startsWith(`${namespace}/`)) {
+  const isTrustedDocumentationUrl = url.protocol === "https:" && url.hostname === "langwatch.ai" && url.port === "" && url.username === "" && url.password === "" && url.pathname.startsWith(`${namespace}/`);
+  if (!isTrustedDocumentationUrl) {
     throw documentationUrlError(namespace);
   }
   const lowerPath = url.pathname.toLowerCase();
@@ -192,7 +145,8 @@ var DATASET_COLUMN_TYPES = [
   "chat_messages",
   "annotations",
   "evaluations",
-  "image"
+  "image",
+  "file"
 ];
 var datasetColumnTypeSchema = z.enum(DATASET_COLUMN_TYPES);
 var datasetColumnDefinitionSchema = z.object({
@@ -234,78 +188,45 @@ var isFailedRow = ({
   entry,
   evaluations
 }) => Boolean(entry.error) || evaluations.some(isFailedEvaluation);
-async function handleExperimentResults(params) {
-  const filter = params.filter ?? "all";
-  const evaluatorFilter = params.evaluator?.trim();
-  const limit = typeof params.limit === "number" && params.limit > 0 ? Math.min(params.limit, DEFAULT_ROW_CAP) : DEFAULT_ROW_CAP;
+function hasNumericStatus(error) {
+  if (typeof error !== "object" || error === null) return false;
+  return "status" in error && typeof error.status === "number";
+}
+function isNotFoundError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  let status;
+  if (error instanceof LangWatchApiError) status = error.status;
+  else if (hasNumericStatus(error)) status = error.status;
+  return status === 404 || status === void 0 && /404|not found/i.test(message);
+}
+async function fetchRunResults(params) {
   const search = new URLSearchParams();
   if (params.experimentSlug) search.set("experimentSlug", params.experimentSlug);
   const qs = search.toString() ? `?${search.toString()}` : "";
-  let results;
-  try {
-    results = await makeRequest(
-      "GET",
-      `/api/experiments/runs/${encodeURIComponent(params.runId)}/results${qs}`
-    );
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    const status = error instanceof LangWatchApiError ? error.status : error && typeof error === "object" && "status" in error && typeof error.status === "number" ? error.status : void 0;
-    if (status === 404 || status === void 0 && /404|not found/i.test(message)) {
-      return [
-        `# Evaluation Results: ${params.runId}`,
-        "",
-        "**Status**: not found",
-        "",
-        `Could not load results for run \`${params.runId}\`. The run id may be incorrect, or its run state may have expired (Redis keeps it for 24h).`,
-        "",
-        "> Pass `experimentSlug` to load results for runs older than 24h. Discover the slug with `platform_experiment_list`, then `platform_experiment_list_runs` for the run ids."
-      ].join("\n");
-    }
-    throw error;
-  }
-  if (!results) {
-    return [
-      `# Evaluation Results: ${params.runId}`,
-      "",
-      "**Status**: not found",
-      "",
-      `Could not load results for run \`${params.runId}\`.`,
-      "",
-      "> Pass `experimentSlug` if the run is older than 24h. Discover the slug with `platform_experiment_list`, then `platform_experiment_list_runs` to confirm the run id."
-    ].join("\n");
-  }
-  const runStatus2 = deriveRunStatus(results.timestamps);
-  const partial = !isTerminalStatus(runStatus2);
-  const evaluationsByRow = /* @__PURE__ */ new Map();
-  for (const evaluation of results.evaluations) {
+  return await makeRequest(
+    "GET",
+    `/api/v1/experiments/runs/${encodeURIComponent(params.runId)}/results${qs}`
+  );
+}
+function groupEvaluationsByRow({
+  evaluations,
+  evaluatorFilter
+}) {
+  const byRow = /* @__PURE__ */ new Map();
+  for (const evaluation of evaluations) {
     if (evaluatorFilter && evaluation.evaluator !== evaluatorFilter) continue;
     const key = rowKey(evaluation.index, evaluation.targetId);
-    const list = evaluationsByRow.get(key) ?? [];
+    const list = byRow.get(key) ?? [];
     list.push(evaluation);
-    evaluationsByRow.set(key, list);
-  }
-  const evaluatorNames = Array.from(
-    new Set(
-      (evaluatorFilter ? results.evaluations.filter((e) => e.evaluator === evaluatorFilter) : results.evaluations).map((e) => e.evaluator)
-    )
-  );
-  let rows = results.dataset.map((entry) => ({
-    entry,
-    evaluations: evaluationsByRow.get(rowKey(entry.index, entry.targetId)) ?? []
-  }));
-  if (filter === "failed") {
-    rows = rows.filter(
-      (r) => isFailedRow({ entry: r.entry, evaluations: r.evaluations })
-    );
+    byRow.set(key, list);
   }
-  const totalMatching = rows.length;
-  const rowsForSummary = rows;
-  const truncated = rows.length > limit;
-  rows = rows.slice(0, limit);
-  const evaluatorAverages = /* @__PURE__ */ new Map();
-  for (const r of rowsForSummary) {
+  return byRow;
+}
+function tallyEvaluatorStats(rows) {
+  const averages = /* @__PURE__ */ new Map();
+  for (const r of rows) {
     for (const e of r.evaluations) {
-      const stats = evaluatorAverages.get(e.evaluator) ?? {
+      const stats = averages.get(e.evaluator) ?? {
         sum: 0,
         count: 0,
         passed: 0,
@@ -319,97 +240,153 @@ async function handleExperimentResults(params) {
       if (e.status === "error") stats.errored += 1;
       else if (e.passed === true) stats.passed += 1;
       else if (e.passed === false) stats.failed += 1;
-      evaluatorAverages.set(e.evaluator, stats);
+      averages.set(e.evaluator, stats);
     }
   }
+  return averages;
+}
+function headerLines({
+  results,
+  runStatus: runStatus2,
+  filter,
+  evaluatorFilter
+}) {
   const lines = [];
   lines.push(`# Evaluation Results: ${results.runId}`);
   lines.push("");
   lines.push(`**Experiment**: ${results.experimentId}`);
   lines.push(`**Status**: ${runStatus2}`);
   if (typeof results.total === "number" && results.total > 0) {
-    lines.push(
-      `**Progress**: ${results.progress ?? results.dataset.length}/${results.total} rows`
-    );
+    lines.push(`**Progress**: ${results.progress ?? results.dataset.length}/${results.total} rows`);
   }
   lines.push(`**Total rows**: ${results.dataset.length}`);
   lines.push(`**Total evaluations**: ${results.evaluations.length}`);
-  if (filter === "failed") {
-    lines.push(`**Filter**: failed only`);
-  }
-  if (evaluatorFilter) {
-    lines.push(`**Evaluator filter**: ${evaluatorFilter}`);
-  }
-  if (partial) {
+  if (filter === "failed") lines.push(`**Filter**: failed only`);
+  if (evaluatorFilter) lines.push(`**Evaluator filter**: ${evaluatorFilter}`);
+  if (!isTerminalStatus(runStatus2)) {
     lines.push("");
     lines.push(
       runStatus2 === "interrupted" ? "> These are partial results. The run never sent a finished/stopped marker and has had no updates recently, so it likely was interrupted before completing. The rows below are everything recorded so far." : "> These are partial results. The run is still in progress, so more rows may appear on a later call."
     );
   }
-  lines.push("");
-  if (evaluatorAverages.size > 0) {
-    lines.push("## Evaluator Summary");
-    lines.push("");
-    lines.push("| Evaluator | Avg Score | Passed | Failed | Errored |");
-    lines.push("| --- | --- | --- | --- | --- |");
-    for (const [name, stats] of evaluatorAverages) {
-      const avg = stats.count > 0 ? (stats.sum / stats.count).toFixed(3) : "\u2014";
-      lines.push(
-        `| ${name} | ${avg} | ${stats.passed} | ${stats.failed} | ${stats.errored} |`
-      );
-    }
+  const stored = results.completeness;
+  if (isTerminalStatus(runStatus2) && stored && !stored.complete) {
     lines.push("");
+    lines.push(
+      `> These are partial results. The run has ended, but the platform is still storing it: ${storedCount(stored.dataset)} rows and ${storedCount(stored.evaluations)} evaluations so far. Call again shortly for the whole run.`
+    );
+  }
+  lines.push("");
+  return lines;
+}
+function evaluatorSummaryLines(averages) {
+  if (averages.size === 0) return [];
+  const lines = [
+    "## Evaluator Summary",
+    "",
+    "| Evaluator | Avg Score | Passed | Failed | Errored |",
+    "| --- | --- | --- | --- | --- |"
+  ];
+  for (const [name, stats] of averages) {
+    const avg = stats.count > 0 ? (stats.sum / stats.count).toFixed(3) : "\u2014";
+    lines.push(`| ${name} | ${avg} | ${stats.passed} | ${stats.failed} | ${stats.errored} |`);
+  }
+  lines.push("");
+  return lines;
+}
+var storedCount = ({ received, expected }) => expected === null ? `${received}` : `${received} of ${expected}`;
+function noRowsLine({ filter, runStatus: runStatus2 }) {
+  if (filter === "failed") return "_No rows matched the filter._";
+  if (runStatus2 === "running")
+    return "_No rows recorded yet. The run is still in progress; call again shortly._";
+  if (runStatus2 === "interrupted") return "_No rows were recorded before the run was interrupted._";
+  return "_No rows recorded for this run._";
+}
+function evaluationLines(e) {
+  const parts = [`**${e.evaluator}**`];
+  if (e.status === "error") parts.push("status=error");
+  else if (typeof e.score === "number") parts.push(`score=${e.score.toFixed(3)}`);
+  if (typeof e.passed === "boolean") parts.push(`passed=${e.passed ? "yes" : "no"}`);
+  if (e.label) parts.push(`label=${e.label}`);
+  const lines = [`- ${parts.join(" \xB7 ")}`];
+  if (e.details) lines.push(`  - details: ${e.details}`);
+  return lines;
+}
+function rowLines({
+  row: { entry, evaluations },
+  anyEvaluators
+}) {
+  const summary = summarizeEntry(entry.entry);
+  const lines = [`### Row #${entry.index}${summary ? ` \u2014 ${summary}` : ""}`];
+  if (entry.error) lines.push(`- **Error**: ${entry.error}`);
+  if (entry.traceId) lines.push(`- **Trace ID**: \`${entry.traceId}\``);
+  if (evaluations.length === 0) {
+    lines.push(
+      anyEvaluators ? "- _No evaluations recorded for this row_" : "- _No evaluations recorded_"
+    );
+  }
+  for (const e of evaluations) lines.push(...evaluationLines(e));
+  lines.push("");
+  return lines;
+}
+function notFoundReport({ runId, expired }) {
+  const lines = [`# Evaluation Results: ${runId}`, "", "**Status**: not found", ""];
+  if (expired) {
+    lines.push(
+      `Could not load results for run \`${runId}\`. The run id may be incorrect, or its run state may have expired (Redis keeps it for 24h).`,
+      "",
+      "> Pass `experimentSlug` to load results for runs older than 24h. Discover the slug with `platform_experiment_list`, then `platform_experiment_list_runs` for the run ids."
+    );
+  } else {
+    lines.push(
+      `Could not load results for run \`${runId}\`.`,
+      "",
+      "> Pass `experimentSlug` if the run is older than 24h. Discover the slug with `platform_experiment_list`, then `platform_experiment_list_runs` to confirm the run id."
+    );
+  }
+  return lines.join("\n");
+}
+async function handleExperimentResults(params) {
+  const filter = params.filter ?? "all";
+  const evaluatorFilter = params.evaluator?.trim();
+  const limit = typeof params.limit === "number" && params.limit > 0 ? Math.min(params.limit, DEFAULT_ROW_CAP) : DEFAULT_ROW_CAP;
+  let results;
+  try {
+    results = await fetchRunResults(params);
+  } catch (error) {
+    if (isNotFoundError(error)) return notFoundReport({ runId: params.runId, expired: true });
+    throw error;
   }
+  if (!results) return notFoundReport({ runId: params.runId, expired: false });
+  const runStatus2 = deriveRunStatus(results.timestamps);
+  const evaluationsByRow = groupEvaluationsByRow({
+    evaluations: results.evaluations,
+    evaluatorFilter
+  });
+  const evaluatorNames = new Set(
+    (evaluatorFilter ? results.evaluations.filter((e) => e.evaluator === evaluatorFilter) : results.evaluations).map((e) => e.evaluator)
+  );
+  const allRows = results.dataset.map((entry) => ({
+    entry,
+    evaluations: evaluationsByRow.get(rowKey(entry.index, entry.targetId)) ?? []
+  }));
+  const matching = filter === "failed" ? allRows.filter((r) => isFailedRow(r)) : allRows;
+  const truncated = matching.length > limit;
+  const rows = matching.slice(0, limit);
+  const lines = [
+    ...headerLines({ results, runStatus: runStatus2, filter, evaluatorFilter }),
+    ...evaluatorSummaryLines(tallyEvaluatorStats(matching))
+  ];
   if (rows.length === 0) {
-    if (filter === "failed") {
-      lines.push("_No rows matched the filter._");
-    } else if (runStatus2 === "running") {
-      lines.push(
-        "_No rows recorded yet. The run is still in progress; call again shortly._"
-      );
-    } else if (runStatus2 === "interrupted") {
-      lines.push("_No rows were recorded before the run was interrupted._");
-    } else {
-      lines.push("_No rows recorded for this run._");
-    }
+    lines.push(noRowsLine({ filter, runStatus: runStatus2 }));
     return lines.join("\n");
   }
-  lines.push(
-    `## Rows (${rows.length}${truncated ? ` of ${totalMatching}` : ""})`
-  );
+  lines.push(`## Rows (${rows.length}${truncated ? ` of ${matching.length}` : ""})`);
   lines.push("");
-  for (const { entry, evaluations } of rows) {
-    const summary = summarizeEntry(entry.entry);
-    lines.push(`### Row #${entry.index}${summary ? ` \u2014 ${summary}` : ""}`);
-    if (entry.error) {
-      lines.push(`- **Error**: ${entry.error}`);
-    }
-    if (entry.traceId) {
-      lines.push(`- **Trace ID**: \`${entry.traceId}\``);
-    }
-    if (evaluations.length === 0) {
-      lines.push(
-        evaluatorNames.length === 0 ? "- _No evaluations recorded_" : "- _No evaluations recorded for this row_"
-      );
-    }
-    for (const e of evaluations) {
-      const parts = [`**${e.evaluator}**`];
-      if (e.status === "error") parts.push("status=error");
-      else if (typeof e.score === "number") parts.push(`score=${e.score.toFixed(3)}`);
-      if (typeof e.passed === "boolean") {
-        parts.push(`passed=${e.passed ? "yes" : "no"}`);
-      }
-      if (e.label) parts.push(`label=${e.label}`);
-      lines.push(`- ${parts.join(" \xB7 ")}`);
-      if (e.details) {
-        lines.push(`  - details: ${e.details}`);
-      }
-    }
-    lines.push("");
-  }
+  for (const row of rows) lines.push(...rowLines({ row, anyEvaluators: evaluatorNames.size > 0 }));
   if (truncated) {
     lines.push(
-      `> Output truncated to ${limit} rows of ${totalMatching} matching to protect the agent's context window. Pass \`limit\` to expand or filter further.`
+      `> Output truncated to ${limit} rows of ${matching.length} matching to protect the agent's context window. Pass \`limit\` to expand or filter further.`
     );
   }
   return lines.join("\n");
@@ -450,7 +427,7 @@ async function handleExperimentListRuns(params) {
   try {
     result = await makeRequest(
       "GET",
-      `/api/experiments/runs?${search.toString()}`
+      `/api/v1/experiments/runs?${search.toString()}`
     );
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -520,7 +497,7 @@ async function handleExperimentList(params) {
   search.set("pageSize", String(effectiveLimit));
   const result = await makeRequest(
     "GET",
-    `/api/experiments?${search.toString()}`
+    `/api/v1/experiments?${search.toString()}`
   );
   if (result.experiments.length === 0) {
     return [
@@ -552,9 +529,7 @@ async function handleExperimentList(params) {
     );
   }
   lines.push("");
-  lines.push(
-    "> Use `platform_experiment_list_runs` with one of these slugs to see its runs."
-  );
+  lines.push("> Use `platform_experiment_list_runs` with one of these slugs to see its runs.");
   return lines.join("\n");
 }
 
@@ -562,7 +537,7 @@ async function handleExperimentList(params) {
 async function handleRunExperiment(params) {
   const result = await makeRequest(
     "POST",
-    `/api/experiments/${encodeURIComponent(params.slug)}/run`
+    `/api/v1/experiments/${encodeURIComponent(params.slug)}/run`
   );
   const lines = [];
   lines.push(`Evaluation started!
@@ -585,7 +560,7 @@ async function statusFromResults(params) {
   try {
     results = await makeRequest(
       "GET",
-      `/api/experiments/runs/${encodeURIComponent(params.runId)}/results${qs}`
+      `/api/v1/experiments/runs/${encodeURIComponent(params.runId)}/results${qs}`
     );
   } catch (error) {
     const code = error instanceof LangWatchApiError ? error.status : void 0;
@@ -604,19 +579,13 @@ async function statusFromResults(params) {
   lines.push(`**Status**: ${status}`);
   lines.push(`**Progress**: ${progress}/${total} cells`);
   if (results.timestamps.createdAt) {
-    lines.push(
-      `**Started**: ${new Date(results.timestamps.createdAt).toISOString()}`
-    );
+    lines.push(`**Started**: ${new Date(results.timestamps.createdAt).toISOString()}`);
   }
   if (results.timestamps.finishedAt) {
-    lines.push(
-      `**Finished**: ${new Date(results.timestamps.finishedAt).toISOString()}`
-    );
+    lines.push(`**Finished**: ${new Date(results.timestamps.finishedAt).toISOString()}`);
   }
   if (results.timestamps.stoppedAt) {
-    lines.push(
-      `**Stopped**: ${new Date(results.timestamps.stoppedAt).toISOString()}`
-    );
+    lines.push(`**Stopped**: ${new Date(results.timestamps.stoppedAt).toISOString()}`);
   }
   lines.push("");
   lines.push(
@@ -624,30 +593,36 @@ async function statusFromResults(params) {
   );
   return lines.join("\n");
 }
+async function statusAfterFailedRead({
+  params,
+  error
+}) {
+  const code = error instanceof LangWatchApiError ? error.status : void 0;
+  const message = error instanceof Error ? error.message : String(error);
+  if (code === 404 || /404|not found/i.test(message)) {
+    const fallback = await statusFromResults(params);
+    if (fallback) return fallback;
+    return [
+      `# Evaluation Run ${params.runId}`,
+      "",
+      "**Status**: not found",
+      "",
+      `Could not find run \`${params.runId}\`. SDK-logged runs and runs older than 24h are not in the live run-state and must be resolved by experiment slug.`,
+      "",
+      "> Pass `experimentSlug`: discover it with `platform_experiment_list`, then use `platform_experiment_list_runs` for the run ids. Or fetch the rows directly with `platform_experiment_results`."
+    ].join("\n");
+  }
+  throw error;
+}
 async function handleExperimentStatus(params) {
   let status;
   try {
     status = await makeRequest(
       "GET",
-      `/api/experiments/runs/${encodeURIComponent(params.runId)}`
+      `/api/v1/experiments/runs/${encodeURIComponent(params.runId)}`
     );
   } catch (error) {
-    const code = error instanceof LangWatchApiError ? error.status : void 0;
-    const message = error instanceof Error ? error.message : String(error);
-    if (code === 404 || /404|not found/i.test(message)) {
-      const fallback = await statusFromResults(params);
-      if (fallback) return fallback;
-      return [
-        `# Evaluation Run ${params.runId}`,
-        "",
-        "**Status**: not found",
-        "",
-        `Could not find run \`${params.runId}\`. SDK-logged runs and runs older than 24h are not in the live run-state and must be resolved by experiment slug.`,
-        "",
-        "> Pass `experimentSlug`: discover it with `platform_experiment_list`, then use `platform_experiment_list_runs` for the run ids. Or fetch the rows directly with `platform_experiment_results`."
-      ].join("\n");
-    }
-    throw error;
+    return statusAfterFailedRead({ params, error });
   }
   const lines = [];
   lines.push(`# Evaluation Run ${status.runId}
@@ -669,9 +644,7 @@ async function handleExperimentStatus(params) {
       lines.push(`**Failed**: ${status.summary.failedCells}`);
     }
     if (status.summary.duration) {
-      lines.push(
-        `**Duration**: ${(status.summary.duration / 1e3).toFixed(1)}s`
-      );
+      lines.push(`**Duration**: ${(status.summary.duration / 1e3).toFixed(1)}s`);
     }
     if (status.summary.runUrl) {
       lines.push(`**View results**: ${status.summary.runUrl}`);
@@ -680,6 +653,40 @@ async function handleExperimentStatus(params) {
   return lines.join("\n");
 }
 
+// src/tools/test-agent.ts
+async function handleTestAgent(params) {
+  const run = await testAgent(params.id);
+  return [
+    'Test run scheduled. The user sends "ping"; the run succeeds when the agent answers.',
+    "",
+    `**Scenario run ID:** ${run.scenarioRunId}`,
+    `**Batch run ID:** ${run.batchRunId}`,
+    "",
+    `Follow it with platform_get_simulation_run using scenarioRunId "${run.scenarioRunId}".`
+  ].join("\n");
+}
+
+// src/tools/update-test-suite.ts
+async function handleUpdateTestSuite(params) {
+  const suite = await updateTestSuite({
+    id: params.id,
+    ...params.name !== void 0 ? { name: params.name } : {},
+    ...params.fields !== void 0 ? { fields: params.fields } : {},
+    ...params.evaluators !== void 0 ? { evaluators: toWireAttachments(params.evaluators) } : {}
+  });
+  return [
+    `Test suite "${suite.name}" updated.`,
+    "",
+    `**ID**: ${suite.id}`,
+    `**Slug**: ${suite.slug}`,
+    `**Scenarios**: ${suite.scenarioCount}`,
+    ...formatSuiteFields(suite.fields),
+    ...formatEvaluatorAttachments(suite.evaluators),
+    "",
+    `**View**: ${suite.platformUrl}`
+  ].join("\n");
+}
+
 // src/create-mcp-server.ts
 var modelSchema = z2.string().describe(
   'Model in "provider/model-name" format, e.g., "openai/gpt-4o", "anthropic/claude-sonnet-4-5-20250929"'
@@ -707,6 +714,28 @@ function withToolLogging(toolName, fn) {
   };
 }
 function registerTools(server) {
+  registerDocsTools(server);
+  registerObservabilityTools(server);
+  registerPromptTools(server);
+  registerScenarioTools(server);
+  registerRunPlanTools(server);
+  registerTestSuiteTools(server);
+  registerSimulationRunTools(server);
+  registerEvaluatorTools(server);
+  registerModelProviderTools(server);
+  registerAgentTools(server);
+  registerDashboardTools(server);
+  registerWorkflowTools(server);
+  registerAnnotationTools(server);
+  registerTriggerTools(server);
+  registerMonitorTools(server);
+  registerSecretTools(server);
+  registerExperimentTools(server);
+  registerDatasetTools(server);
+  registerProjectTools(server);
+  registerApiKeyTools(server);
+}
+function registerDocsTools(server) {
   server.tool(
     "fetch_langwatch_docs",
     "Fetches the LangWatch docs for understanding how to implement LangWatch in your codebase. Always use this tool when the user asks for help with LangWatch. Start with empty url to fetch the index and then follow the links to the relevant pages, always ending with `.md` extension",
@@ -738,7 +767,7 @@ function registerTools(server) {
       agent: z2.string().optional().describe("Which coding agent this is, e.g. claude-code, codex, cursor")
     },
     withToolLogging("report_issue", async (params) => {
-      const { handleReportIssue } = await import("./report-issue-XYVAPAYJ.js");
+      const { handleReportIssue } = await import("./report-issue-DCZFLGDO.js");
       return {
         content: [{ type: "text", text: await handleReportIssue(params) }]
       };
@@ -757,70 +786,99 @@ function registerTools(server) {
       return { content: [{ type: "text", text }] };
     })
   );
+}
+function registerObservabilityTools(server) {
   server.tool(
     "discover_schema",
-    "Discover available filter fields, metrics, aggregation types, group-by options, scenario schema, and evaluator types for LangWatch queries. Call this before using search_traces, get_analytics, scenario tools, or evaluator tools to understand available options.",
+    "Discover what LangWatch can be queried with: the trace filter fields and syntax, the analytics SQL views and columns, the analytics metrics, aggregation types, group-by options, scenario schema and evaluator types. Call this before using search_traces, run_query, get_analytics, scenario tools or evaluator tools, so you never guess a field, a column or a value.",
     {
       category: z2.enum([
         "filters",
+        "lwql",
         "metrics",
         "aggregations",
         "groups",
         "scenarios",
         "evaluators",
         "all"
-      ]).describe("Which schema category to discover"),
+      ]).describe(
+        "Which schema category to discover. 'filters' is the trace filter language, 'lwql' the analytics SQL views; both are read from the platform and need the API key"
+      ),
       evaluatorType: z2.string().optional().describe(
         "When category is 'evaluators', provide a specific evaluator type (e.g. 'langevals/llm_boolean') to get its full schema details"
       )
     },
-    async ({ category, evaluatorType }) => {
+    withToolLogging("discover_schema", async ({ category, evaluatorType }) => {
       if (category === "scenarios") {
-        const { formatScenarioSchema } = await import("./discover-scenario-schema-FE64QK2D.js");
+        const { formatScenarioSchema } = await import("./discover-scenario-schema-OOFIQKOG.js");
         return {
           content: [{ type: "text", text: formatScenarioSchema() }]
         };
       }
       if (category === "evaluators") {
-        const { formatEvaluatorSchema } = await import("./discover-evaluator-schema-XTAD4X7D.js");
+        const { formatEvaluatorSchema } = await import("./discover-evaluator-schema-UHWA5HVL.js");
         return {
-          content: [
-            { type: "text", text: formatEvaluatorSchema(evaluatorType) }
-          ]
+          content: [{ type: "text", text: formatEvaluatorSchema(evaluatorType) }]
         };
       }
-      const { formatSchema } = await import("./discover-schema-L6QDPON3.js");
-      let text = formatSchema(category);
+      const { formatSchema, needsQueryReference } = await import("./discover-schema-55YJBFGQ.js");
+      if (needsQueryReference(category)) requireApiKey();
+      let text = await formatSchema(category);
       if (category === "all") {
-        const { formatScenarioSchema } = await import("./discover-scenario-schema-FE64QK2D.js");
+        const { formatScenarioSchema } = await import("./discover-scenario-schema-OOFIQKOG.js");
         text += "\n\n" + formatScenarioSchema();
-        const { formatEvaluatorSchema } = await import("./discover-evaluator-schema-XTAD4X7D.js");
+        const { formatEvaluatorSchema } = await import("./discover-evaluator-schema-UHWA5HVL.js");
         text += "\n\n" + formatEvaluatorSchema();
       }
       return { content: [{ type: "text", text }] };
-    }
+    })
+  );
+  server.tool(
+    "run_query",
+    "Run one read-only analytics SQL statement (LangWatchQL) over this project's traces, spans, evaluations and metrics, and get the rows back as a table. This is the tool for a count, a rate, a sum, a percentile or any of them grouped or over time \u2014 questions search_traces would need many calls to answer. The statement runs exactly as written. Call discover_schema with category 'lwql' first for the views, columns and worked statements.",
+    {
+      sql: z2.string().describe(
+        "The SELECT to run. Filter on the dataset's time column so the read is bounded, and never select a whole attribute map"
+      ),
+      parameters: z2.record(z2.string(), z2.union([z2.string(), z2.number(), z2.boolean(), z2.null()])).optional().describe(
+        'Values for the parameters the statement declares, e.g. {"days": 7} for {days:UInt32}'
+      )
+    },
+    withToolLogging("run_query", async (params) => {
+      requireApiKey();
+      const { handleRunQuery } = await import("./run-query-KJDH544C.js");
+      return {
+        content: [{ type: "text", text: await handleRunQuery(params) }]
+      };
+    })
   );
   server.tool(
     "search_traces",
-    "Search LangWatch traces with filters, text query, and date range. Returns AI-readable trace digests by default. Use format: 'json' for full raw data.",
+    "Search LangWatch traces by content, with filters and a date range. Returns AI-readable trace digests by default. Use format: 'json' for full raw data. To fetch a trace you already have the ID for, use get_trace instead \u2014 free text does not match trace IDs.",
     {
-      query: z2.string().optional().describe("Text search query"),
+      query: z2.string().optional().describe(
+        "Text search query. Matches captured input/output, the trace name and span names ONLY. It does not match trace IDs \u2014 to fetch a known trace ID use get_trace, or pass traceIds here for several at once."
+      ),
+      traceIds: z2.array(z2.string().min(1)).min(1).max(1e3).optional().describe(
+        "Exact trace IDs to fetch (1\u20131000). Use instead of query when you already know the IDs. When set and no startDate is given, the window defaults to the last 90 days rather than 24 hours."
+      ),
       filters: z2.record(z2.string(), z2.array(z2.string())).optional().describe(
-        'Filter traces. Format: {"field": ["value"]}. Use discover_schema for field names.'
+        'Filter traces by the older per-field map. Format: {"field": ["value"]}. Use discover_schema for field names.'
+      ),
+      filter: z2.string().optional().describe(
+        'Filter traces with the Trace Explorer\'s own query language: "status:error AND model:gpt-*", "trace.attribute.langwatch.user_id:alice", "evaluatorVerdict:fail", a quoted phrase for free text. Reaches attribute keys, span events and evaluator verdicts that the `filters` map cannot. Combined with `filters` and `query` when you send more than one. Call discover_schema with category \'filters\' for every field and the syntax.'
       ),
-      startDate: z2.string().optional().describe(
-        'Start date: ISO string or relative like "24h", "7d", "30d". Default: 24h ago'
+      startDate: z2.string().min(1).optional().describe(
+        'Start of the window: ISO date, or relative like "24h", "7d", "4w", "3m" \u2014 units are h (hours), d (days), w (weeks), m (30-day months). Defaults to 24h ago for a text search, or 90d when traceIds is set. Widen this when a search comes back empty.'
       ),
-      endDate: z2.string().optional().describe("End date: ISO string or relative. Default: now"),
+      endDate: z2.string().min(1).optional().describe("End of the window: ISO date or relative. Default: now"),
       pageSize: z2.number().optional().describe("Results per page (default: 25, max: 1000)"),
       scrollId: z2.string().optional().describe("Pagination token from previous search"),
-      format: z2.enum(["digest", "json"]).optional().describe(
-        "Output format: 'digest' (default, AI-readable) or 'json' (full raw data)"
-      )
+      format: z2.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
     },
     withToolLogging("search_traces", async (params) => {
       requireApiKey();
-      const { handleSearchTraces } = await import("./search-traces-A6HFKPLJ.js");
+      const { handleSearchTraces } = await import("./search-traces-HSTQ6WTQ.js");
       return {
         content: [{ type: "text", text: await handleSearchTraces(params) }]
       };
@@ -828,16 +886,16 @@ function registerTools(server) {
   );
   server.tool(
     "get_trace",
-    "Get full details of a single trace by ID. Returns AI-readable trace digest by default. Use format: 'json' for full raw data including all spans.",
+    "Get full details of a single trace by ID. This is the right tool whenever you have a trace ID \u2014 search_traces does not match IDs. A full ID resolves at any age; a unique 8\u201331 character hex prefix resolves within the last 90 days. Returns AI-readable trace digest by default. Use format: 'json' for full raw data including all spans.",
     {
-      traceId: z2.string().describe("The trace ID to retrieve"),
-      format: z2.enum(["digest", "json"]).optional().describe(
-        "Output format: 'digest' (default, AI-readable) or 'json' (full raw data)"
-      )
+      traceId: z2.string().describe(
+        "The trace ID to retrieve. A full ID resolves at any age; a unique 8\u201331 character hex prefix also resolves, git-style, within the last 90 days."
+      ),
+      format: z2.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
     },
     withToolLogging("get_trace", async (params) => {
       requireApiKey();
-      const { handleGetTrace } = await import("./get-trace-K7U234Q4.js");
+      const { handleGetTrace } = await import("./get-trace-SEF3FMR5.js");
       return {
         content: [{ type: "text", text: await handleGetTrace(params) }]
       };
@@ -853,9 +911,7 @@ function registerTools(server) {
       aggregation: z2.string().optional().describe(
         "Aggregation type: avg, sum, min, max, median, p90, p95, p99, cardinality, terms. Default: avg"
       ),
-      startDate: z2.string().optional().describe(
-        'Start date: ISO or relative ("7d", "30d"). Default: 7 days ago'
-      ),
+      startDate: z2.string().optional().describe('Start date: ISO or relative ("7d", "30d"). Default: 7 days ago'),
       endDate: z2.string().optional().describe("End date. Default: now"),
       timeZone: z2.string().optional().describe("Timezone. Default: UTC"),
       groupBy: z2.string().optional().describe("Group results by field. Use discover_schema for options."),
@@ -863,12 +919,14 @@ function registerTools(server) {
     },
     withToolLogging("get_analytics", async (params) => {
       requireApiKey();
-      const { handleGetAnalytics } = await import("./get-analytics-TETCSOK6.js");
+      const { handleGetAnalytics } = await import("./get-analytics-DCS72353.js");
       return {
         content: [{ type: "text", text: await handleGetAnalytics(params) }]
       };
     })
   );
+}
+function registerPromptTools(server) {
   server.tool(
     "platform_create_prompt",
     `Create a new prompt on the LangWatch platform.
@@ -881,9 +939,7 @@ NOTE: Prompts can be managed two ways. Determine which approach the user needs:
 `,
     {
       name: z2.string().describe("Prompt display name"),
-      handle: z2.string().optional().describe(
-        "URL-friendly handle (auto-generated from name if omitted)"
-      ),
+      handle: z2.string().optional().describe("URL-friendly handle (auto-generated from name if omitted)"),
       messages: z2.array(
         z2.object({
           role: z2.enum(["system", "user", "assistant"]).describe("Message role"),
@@ -897,7 +953,7 @@ NOTE: Prompts can be managed two ways. Determine which approach the user needs:
     },
     withToolLogging("platform_create_prompt", async (params) => {
       requireApiKey();
-      const { handleCreatePrompt } = await import("./create-prompt-F5RMX3L3.js");
+      const { handleCreatePrompt } = await import("./create-prompt-E67LXIYT.js");
       return {
         content: [{ type: "text", text: await handleCreatePrompt(params) }]
       };
@@ -909,7 +965,7 @@ NOTE: Prompts can be managed two ways. Determine which approach the user needs:
     {},
     withToolLogging("platform_list_prompts", async () => {
       requireApiKey();
-      const { handleListPrompts } = await import("./list-prompts-SC2HAUFG.js");
+      const { handleListPrompts } = await import("./list-prompts-HSIMMHTF.js");
       return {
         content: [{ type: "text", text: await handleListPrompts() }]
       };
@@ -917,13 +973,14 @@ NOTE: Prompts can be managed two ways. Determine which approach the user needs:
   );
   server.tool(
     "platform_get_prompt",
-    "Get a specific prompt from the LangWatch platform by ID or handle, including messages, model config, and version history.",
+    "Get a specific prompt from the LangWatch platform by ID or handle, including messages, model config, and version history. Use format: 'json' for the full raw API payload, or 'digest' (default) for a formatted summary.",
     {
       idOrHandle: z2.string().describe("Prompt ID or handle"),
       version: z2.number().optional().describe("Specific version number (default: latest)"),
       tag: z2.string().optional().describe(
         'Fetch the version pointed to by this tag (e.g., "production", "staging"). Alternatively, use shorthand in idOrHandle: "pizza-prompt:production"'
-      )
+      ),
+      format: z2.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
     },
     withToolLogging("platform_get_prompt", async (params) => {
       if (params.version != null && params.tag) {
@@ -933,7 +990,7 @@ NOTE: Prompts can be managed two ways. Determine which approach the user needs:
         };
       }
       requireApiKey();
-      const { handleGetPrompt } = await import("./get-prompt-OY5B7TRI.js");
+      const { handleGetPrompt } = await import("./get-prompt-OWXJZHQQ.js");
       return {
         content: [{ type: "text", text: await handleGetPrompt(params) }]
       };
@@ -952,13 +1009,11 @@ NOTE: Prompts can be managed two ways. Determine which approach the user needs:
       ).optional().describe("Updated messages"),
       model: modelSchema.optional(),
       commitMessage: z2.string().describe("Commit message describing the change"),
-      tags: z2.array(z2.string()).optional().describe(
-        "Tags to assign to the new version created by this update."
-      )
+      tags: z2.array(z2.string()).optional().describe("Tags to assign to the new version created by this update.")
     },
     withToolLogging("platform_update_prompt", async (params) => {
       requireApiKey();
-      const { handleUpdatePrompt } = await import("./update-prompt-ODCRQRN6.js");
+      const { handleUpdatePrompt } = await import("./update-prompt-MY263DYF.js");
       return {
         content: [{ type: "text", text: await handleUpdatePrompt(params) }]
       };
@@ -974,7 +1029,7 @@ NOTE: Prompts can be managed two ways. Determine which approach the user needs:
     },
     withToolLogging("platform_assign_prompt_tag", async (params) => {
       requireApiKey();
-      const { handleAssignPromptTag } = await import("./assign-prompt-tag-VLXUWEKU.js");
+      const { handleAssignPromptTag } = await import("./assign-prompt-tag-HBZLBIFD.js");
       return {
         content: [{ type: "text", text: await handleAssignPromptTag(params) }]
       };
@@ -986,7 +1041,7 @@ NOTE: Prompts can be managed two ways. Determine which approach the user needs:
     {},
     withToolLogging("platform_list_prompt_tags", async () => {
       requireApiKey();
-      const { handleListPromptTags } = await import("./list-prompt-tags-FOO6TNHB.js");
+      const { handleListPromptTags } = await import("./list-prompt-tags-NVFQO6WX.js");
       return {
         content: [{ type: "text", text: await handleListPromptTags() }]
       };
@@ -1000,7 +1055,7 @@ NOTE: Prompts can be managed two ways. Determine which approach the user needs:
     },
     withToolLogging("platform_create_prompt_tag", async (params) => {
       requireApiKey();
-      const { handleCreatePromptTag } = await import("./create-prompt-tag-GMRWTEFR.js");
+      const { handleCreatePromptTag } = await import("./create-prompt-tag-OPQUEXWB.js");
       return {
         content: [{ type: "text", text: await handleCreatePromptTag(params) }]
       };
@@ -1015,7 +1070,7 @@ NOTE: Prompts can be managed two ways. Determine which approach the user needs:
     },
     withToolLogging("platform_rename_prompt_tag", async (params) => {
       requireApiKey();
-      const { handleRenamePromptTag } = await import("./rename-prompt-tag-EKWU5QF3.js");
+      const { handleRenamePromptTag } = await import("./rename-prompt-tag-IQI7MHOI.js");
       return {
         content: [{ type: "text", text: await handleRenamePromptTag(params) }]
       };
@@ -1029,12 +1084,14 @@ NOTE: Prompts can be managed two ways. Determine which approach the user needs:
     },
     withToolLogging("platform_delete_prompt_tag", async (params) => {
       requireApiKey();
-      const { handleDeletePromptTag } = await import("./delete-prompt-tag-KNMZVSPB.js");
+      const { handleDeletePromptTag } = await import("./delete-prompt-tag-YYQ4VMAD.js");
       return {
         content: [{ type: "text", text: await handleDeletePromptTag(params) }]
       };
     })
   );
+}
+function registerScenarioTools(server) {
   server.tool(
     "platform_create_scenario",
     `Create a new scenario on the LangWatch platform. Call discover_schema({ category: 'scenarios' }) first to learn how to write effective situations and criteria.
@@ -1047,21 +1104,19 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
 `,
     {
       name: z2.string().describe("Scenario name"),
-      situation: z2.string().describe(
-        "The context or setup describing what the user/agent is doing"
-      ),
-      criteria: z2.array(z2.string()).optional().describe(
-        "Pass/fail conditions the agent's response must satisfy"
+      situation: z2.string().describe("The context or setup describing what the user/agent is doing"),
+      criteria: z2.array(z2.string()).optional().describe("Pass/fail conditions the agent's response must satisfy"),
+      labels: z2.array(z2.string()).optional().describe("Tags for organizing and filtering scenarios"),
+      testSuiteId: z2.string().nullish().describe(
+        "The test suite to file this scenario in. Pass a test suite ID, or null to unfile it."
       ),
-      labels: z2.array(z2.string()).optional().describe("Tags for organizing and filtering scenarios")
+      fields: scenarioFieldValuesSchema.optional()
     },
     withToolLogging("platform_create_scenario", async (params) => {
       requireApiKey();
-      const { handleCreateScenario } = await import("./create-scenario-JDR2VB2H.js");
+      const { handleCreateScenario } = await import("./create-scenario-UEM77OE7.js");
       return {
-        content: [
-          { type: "text", text: await handleCreateScenario(params) }
-        ]
+        content: [{ type: "text", text: await handleCreateScenario(params) }]
       };
     })
   );
@@ -1069,17 +1124,14 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     "platform_list_scenarios",
     "List all scenarios on the LangWatch platform. Returns AI-readable digest by default.",
     {
-      format: z2.enum(["digest", "json"]).optional().describe(
-        "Output format: 'digest' (default, AI-readable) or 'json' (full raw data)"
-      )
+      testSuiteId: z2.string().optional().describe("Only the scenarios filed in this test suite"),
+      format: z2.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
     },
     withToolLogging("platform_list_scenarios", async (params) => {
       requireApiKey();
-      const { handleListScenarios } = await import("./list-scenarios-F2WYNRIE.js");
+      const { handleListScenarios } = await import("./list-scenarios-QZRPVHS4.js");
       return {
-        content: [
-          { type: "text", text: await handleListScenarios(params) }
-        ]
+        content: [{ type: "text", text: await handleListScenarios(params) }]
       };
     })
   );
@@ -1088,13 +1140,11 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     "Get full details of a scenario on the LangWatch platform by ID, including situation, criteria, and labels.",
     {
       scenarioId: z2.string().describe("The scenario ID to retrieve"),
-      format: z2.enum(["digest", "json"]).optional().describe(
-        "Output format: 'digest' (default, AI-readable) or 'json' (full raw data)"
-      )
+      format: z2.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
     },
     withToolLogging("platform_get_scenario", async (params) => {
       requireApiKey();
-      const { handleGetScenario } = await import("./get-scenario-ZTAJJL5T.js");
+      const { handleGetScenario } = await import("./get-scenario-YM4ODWW6.js");
       return {
         content: [{ type: "text", text: await handleGetScenario(params) }]
       };
@@ -1108,15 +1158,17 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
       name: z2.string().optional().describe("Updated scenario name"),
       situation: z2.string().optional().describe("Updated situation"),
       criteria: z2.array(z2.string()).optional().describe("Updated criteria"),
-      labels: z2.array(z2.string()).optional().describe("Updated labels")
+      labels: z2.array(z2.string()).optional().describe("Updated labels"),
+      testSuiteId: z2.string().nullish().describe(
+        "The test suite to file this scenario in. Pass a test suite ID, or null to unfile it."
+      ),
+      fields: scenarioFieldValuesSchema.optional()
     },
     withToolLogging("platform_update_scenario", async (params) => {
       requireApiKey();
-      const { handleUpdateScenario } = await import("./update-scenario-NEXCAQI7.js");
+      const { handleUpdateScenario } = await import("./update-scenario-MOHRQKAQ.js");
       return {
-        content: [
-          { type: "text", text: await handleUpdateScenario(params) }
-        ]
+        content: [{ type: "text", text: await handleUpdateScenario(params) }]
       };
     })
   );
@@ -1128,110 +1180,235 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     },
     withToolLogging("platform_archive_scenario", async (params) => {
       requireApiKey();
-      const { handleArchiveScenario } = await import("./archive-scenario-W6BXYDZ3.js");
+      const { handleArchiveScenario } = await import("./archive-scenario-A6QV5LOW.js");
       return {
-        content: [
-          { type: "text", text: await handleArchiveScenario(params) }
-        ]
+        content: [{ type: "text", text: await handleArchiveScenario(params) }]
+      };
+    })
+  );
+}
+function registerRunPlanTools(server) {
+  server.tool(
+    "platform_run_plan",
+    "Run scenarios against targets. The plan name identifies the run plan: an existing name is re-run with the configuration you send here, a new name creates the plan. Configuration is the scope, the targets, the repeat count and the models; parameters, the note and the idempotency key belong to this run alone. Send more than one target to compare them in the same run, and give a target its own parameters to compare one agent on two models.",
+    {
+      name: z2.string().optional().describe(
+        "The run plan to run. An existing name is replaced with this configuration, a new name creates the plan. Omit to let the server name it after the suite and the target."
+      ),
+      scope: runPlanScopeSchema.describe(
+        "What the plan covers: every scenario in the project, the scenarios filed in given test suites, the scenarios carrying given labels, or the hand-picked list in scenarioIds."
+      ),
+      scenarioIds: z2.array(z2.string()).optional().describe("The scenarios to run. Read only when scope.mode is 'scenarios'."),
+      targets: z2.array(runPlanTargetSchema).describe(
+        "What to run the scenarios against. Every target runs every scenario, and the results show one column for each, so this is how one run compares two agents or one agent on two models."
+      ),
+      repeatCount: z2.number().int().min(1).max(5).optional().describe("How many times to run each scenario against each target (1 to 5, default 1)"),
+      simulatorModel: z2.string().optional().describe("Model that plays the user. Omit for the project default."),
+      judgeModel: z2.string().optional().describe("Model that judges the criteria. Omit for the project default."),
+      evaluators: evaluatorAttachmentsSchema.optional().describe(
+        "The plan's own evaluators, run beside the ones attached to the test suites its scenarios belong to. A plan evaluator reads the conversation and the trace, never a scenario field. Omit to keep what the plan already holds. See discover_schema({ category: 'scenarios' }) for the mapping paths."
+      ),
+      parameters: runParametersSchema.optional().describe(
+        "Values for the parameters the scenarios declare, by name. They apply to every target; a target that names the same parameter overrides them for itself."
+      ),
+      note: z2.string().max(200).optional().describe("One short line saying why this run was started (max 200 characters)"),
+      idempotencyKey: z2.string().optional().describe(
+        "Send the same key to make a retry join the run it already started instead of starting a second one."
+      )
+    },
+    withToolLogging("platform_run_plan", async (params) => {
+      requireApiKey();
+      const { handleRunPlan } = await import("./run-plan-PAARQSI4.js");
+      return {
+        content: [{ type: "text", text: await handleRunPlan(params) }]
+      };
+    })
+  );
+  server.tool(
+    "platform_list_run_plans",
+    "List the run plans of the project. A run plan holds the configuration a run used, keyed by its name.",
+    {
+      includeArchived: z2.boolean().optional().describe("Include archived plans (default false)"),
+      format: z2.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default) or 'json' (raw data)")
+    },
+    withToolLogging("platform_list_run_plans", async (params) => {
+      requireApiKey();
+      const { handleListRunPlans } = await import("./list-run-plans-PX2XI6EK.js");
+      return {
+        content: [{ type: "text", text: await handleListRunPlans(params) }]
+      };
+    })
+  );
+  server.tool(
+    "platform_get_run_plan",
+    "Get the full configuration of a run plan: what it covers, its targets, its repeat count and its models.",
+    {
+      id: z2.string().describe("The run plan ID"),
+      format: z2.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default) or 'json'")
+    },
+    withToolLogging("platform_get_run_plan", async (params) => {
+      requireApiKey();
+      const { handleGetRunPlan } = await import("./get-run-plan-BE3M2AUX.js");
+      return {
+        content: [{ type: "text", text: await handleGetRunPlan(params) }]
+      };
+    })
+  );
+  server.tool(
+    "platform_rerun_run_plan",
+    "Run a plan again with the configuration it already holds. Only the parameters and the note belong to the new run.",
+    {
+      id: z2.string().describe("The run plan ID to run again"),
+      parameters: runParametersSchema.optional().describe("Values for the parameters the scenarios declare, by name."),
+      note: z2.string().max(200).optional().describe("One short line saying why this run was started (max 200 characters)")
+    },
+    withToolLogging("platform_rerun_run_plan", async (params) => {
+      requireApiKey();
+      const { handleRerunRunPlan } = await import("./rerun-run-plan-TG2V4WM4.js");
+      return {
+        content: [{ type: "text", text: await handleRerunRunPlan(params) }]
+      };
+    })
+  );
+  server.tool(
+    "platform_archive_run_plan",
+    "Archive a run plan. Its past runs stay readable and the name is free for a new plan.",
+    {
+      id: z2.string().describe("The run plan ID to archive")
+    },
+    withToolLogging("platform_archive_run_plan", async (params) => {
+      requireApiKey();
+      const { handleArchiveRunPlan } = await import("./archive-run-plan-65QN3XRX.js");
+      return {
+        content: [{ type: "text", text: await handleArchiveRunPlan(params) }]
       };
     })
   );
+}
+function registerTestSuiteTools(server) {
   server.tool(
-    "platform_list_suites",
-    "List all suites (run plans) on the LangWatch platform. A suite bundles scenarios with targets for batch execution.",
+    "platform_list_test_suites",
+    "List the test suites of the project. A test suite groups scenarios.",
     {
       format: z2.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default) or 'json' (raw data)")
     },
-    withToolLogging("platform_list_suites", async (params) => {
+    withToolLogging("platform_list_test_suites", async (params) => {
+      requireApiKey();
+      const { handleListTestSuites } = await import("./list-test-suites-N4WVLBKK.js");
+      return {
+        content: [{ type: "text", text: await handleListTestSuites(params) }]
+      };
+    })
+  );
+  server.tool(
+    "platform_create_test_suite",
+    "Create a test suite. A test suite groups scenarios: file a scenario in it by passing the suite ID as testSuiteId on platform_create_scenario or platform_update_scenario. A suite can declare typed fields every scenario carries a value for, and attach saved evaluators that run after every scenario run with mappings from their inputs to the conversation, the scenario's fields or the trace. Call discover_schema({ category: 'scenarios' }) first for the field rules and the mapping paths.",
+    {
+      name: z2.string().describe("Test suite name"),
+      fields: suiteFieldsSchema.optional(),
+      evaluators: evaluatorAttachmentsSchema.optional()
+    },
+    withToolLogging("platform_create_test_suite", async (params) => {
       requireApiKey();
-      const { handleListSuites } = await import("./list-suites-CRY4VWW6.js");
+      const { handleCreateTestSuite } = await import("./create-test-suite-4IPXVSFQ.js");
       return {
-        content: [{ type: "text", text: await handleListSuites(params) }]
+        content: [{ type: "text", text: await handleCreateTestSuite(params) }]
       };
     })
   );
   server.tool(
-    "platform_get_suite",
-    "Get detailed information about a specific suite (run plan) by ID.",
+    "platform_get_test_suite",
+    "Get a test suite and the scenarios filed in it.",
     {
-      id: z2.string().describe("The suite ID"),
+      id: z2.string().describe("The test suite ID"),
       format: z2.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default) or 'json'")
     },
-    withToolLogging("platform_get_suite", async (params) => {
+    withToolLogging("platform_get_test_suite", async (params) => {
       requireApiKey();
-      const { handleGetSuite } = await import("./get-suite-J7JVWO6O.js");
+      const { handleGetTestSuite } = await import("./get-test-suite-GC2O7YH6.js");
       return {
-        content: [{ type: "text", text: await handleGetSuite(params) }]
+        content: [{ type: "text", text: await handleGetTestSuite(params) }]
       };
     })
   );
   server.tool(
-    "platform_create_suite",
-    "Create a new suite (run plan) that bundles scenarios with targets for batch execution.",
+    "platform_update_test_suite",
+    "Edit a test suite: any of its name, its fields and its evaluators. A field list or an evaluator list replaces the one the suite holds; a key left out keeps what the suite has. A field an attached evaluator still reads cannot be removed. Call discover_schema({ category: 'scenarios' }) first for the field rules and the mapping paths.",
     {
-      name: z2.string().describe("Suite name"),
-      description: z2.string().optional().describe("Suite description"),
-      scenarioIds: z2.array(z2.string()).describe("Array of scenario IDs to include"),
-      targets: z2.string().describe('JSON array of target objects, e.g. [{"type":"http","referenceId":"agent_abc"}]'),
-      repeatCount: z2.number().optional().describe("Number of times to repeat each scenario-target pair (default: 1)"),
-      labels: z2.array(z2.string()).optional().describe("Tags for organizing suites")
+      id: z2.string().describe("The test suite ID"),
+      name: z2.string().optional().describe("The new name. The slug is kept."),
+      fields: suiteFieldsSchema.optional().describe(
+        "The full list of fields the suite declares. It replaces the list the suite holds."
+      ),
+      evaluators: evaluatorAttachmentsSchema.optional().describe(
+        "The full list of evaluators attached to the suite. It replaces the list the suite holds."
+      )
     },
-    withToolLogging("platform_create_suite", async (params) => {
+    withToolLogging("platform_update_test_suite", async (params) => {
       requireApiKey();
-      const { handleCreateSuite } = await import("./create-suite-LZS6QIAF.js");
       return {
-        content: [{ type: "text", text: await handleCreateSuite(params) }]
+        content: [{ type: "text", text: await handleUpdateTestSuite(params) }]
       };
     })
   );
   server.tool(
-    "platform_update_suite",
-    "Update an existing suite (run plan).",
+    "platform_rename_test_suite",
+    "Rename a test suite.",
     {
-      id: z2.string().describe("The suite ID to update"),
-      name: z2.string().optional().describe("New suite name"),
-      description: z2.string().optional().describe("New description"),
-      scenarioIds: z2.array(z2.string()).optional().describe("New array of scenario IDs"),
-      targets: z2.string().optional().describe("New JSON array of targets"),
-      repeatCount: z2.number().optional().describe("New repeat count"),
-      labels: z2.array(z2.string()).optional().describe("New labels")
+      id: z2.string().describe("The test suite ID"),
+      name: z2.string().describe("The new name")
     },
-    withToolLogging("platform_update_suite", async (params) => {
+    withToolLogging("platform_rename_test_suite", async (params) => {
       requireApiKey();
-      const { handleUpdateSuite } = await import("./update-suite-SNO3GS7T.js");
+      const { handleRenameTestSuite } = await import("./rename-test-suite-4J7UX5S2.js");
       return {
-        content: [{ type: "text", text: await handleUpdateSuite(params) }]
+        content: [{ type: "text", text: await handleRenameTestSuite(params) }]
       };
     })
   );
   server.tool(
-    "platform_run_suite",
-    "Trigger a suite run. Schedules all scenario x target x repeat jobs for execution.",
+    "platform_archive_test_suite",
+    "Archive a test suite. The scenarios filed in it are archived with it.",
     {
-      id: z2.string().describe("The suite ID to run")
+      id: z2.string().describe("The test suite ID to archive")
     },
-    withToolLogging("platform_run_suite", async (params) => {
+    withToolLogging("platform_archive_test_suite", async (params) => {
       requireApiKey();
-      const { handleRunSuite } = await import("./run-suite-NKZCJ2IN.js");
+      const { handleArchiveTestSuite } = await import("./archive-test-suite-NKZDZY3D.js");
       return {
-        content: [{ type: "text", text: await handleRunSuite(params) }]
+        content: [{ type: "text", text: await handleArchiveTestSuite(params) }]
       };
     })
   );
   server.tool(
-    "platform_archive_suite",
-    "Archive (soft-delete) a suite (run plan).",
+    "platform_run_test_suite",
+    "Run every scenario of a test suite against targets. This creates or joins the run plan named '<suite name> <target name>' unless you send a name of your own. Send more than one target to compare them in the same run, and give a target its own parameters to compare one agent on two models.",
     {
-      id: z2.string().describe("The suite ID to archive")
+      id: z2.string().describe("The test suite ID to run"),
+      targets: z2.array(runPlanTargetSchema).describe(
+        "What to run the scenarios against. Every target runs every scenario, and the results show one column for each."
+      ),
+      name: z2.string().optional().describe(
+        "The run plan to run. Omit to let the server name it after the suite and the target."
+      ),
+      repeatCount: z2.number().int().min(1).max(5).optional().describe("How many times to run each scenario against each target (1 to 5, default 1)"),
+      simulatorModel: z2.string().optional().describe("Model that plays the user. Omit for the project default."),
+      judgeModel: z2.string().optional().describe("Model that judges the criteria. Omit for the project default."),
+      parameters: runParametersSchema.optional().describe(
+        "Values for the parameters the scenarios declare, by name. They apply to every target; a target that names the same parameter overrides them for itself."
+      ),
+      note: z2.string().max(200).optional().describe("One short line saying why this run was started (max 200 characters)")
     },
-    withToolLogging("platform_archive_suite", async (params) => {
+    withToolLogging("platform_run_test_suite", async (params) => {
       requireApiKey();
-      const { handleArchiveSuite } = await import("./archive-suite-4T6BSRS7.js");
+      const { handleRunTestSuite } = await import("./run-test-suite-SQJELEZX.js");
       return {
-        content: [{ type: "text", text: await handleArchiveSuite(params) }]
+        content: [{ type: "text", text: await handleRunTestSuite(params) }]
       };
     })
   );
+}
+function registerSimulationRunTools(server) {
   server.tool(
     "platform_list_simulation_runs",
     "List simulation run results. Filter by scenario set or batch run ID to see specific results.",
@@ -1243,7 +1420,7 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     },
     withToolLogging("platform_list_simulation_runs", async (params) => {
       requireApiKey();
-      const { handleListSimulationRuns } = await import("./list-simulation-runs-KF5THG5H.js");
+      const { handleListSimulationRuns } = await import("./list-simulation-runs-OEADLLQR.js");
       return {
         content: [{ type: "text", text: await handleListSimulationRuns(params) }]
       };
@@ -1251,19 +1428,21 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
   );
   server.tool(
     "platform_get_simulation_run",
-    "Get full details of a simulation run including conversation messages, results, costs, and verdict.",
+    "Get full details of a simulation run including conversation messages, results, costs, the verdict and the result of every evaluator attached to its test suite or run plan.",
     {
       scenarioRunId: z2.string().describe("The simulation run ID"),
       format: z2.enum(["digest", "json"]).optional().describe("Output format")
     },
     withToolLogging("platform_get_simulation_run", async (params) => {
       requireApiKey();
-      const { handleGetSimulationRun } = await import("./get-simulation-run-T2ZQWYH2.js");
+      const { handleGetSimulationRun } = await import("./get-simulation-run-LCFSMPGQ.js");
       return {
         content: [{ type: "text", text: await handleGetSimulationRun(params) }]
       };
     })
   );
+}
+function registerEvaluatorTools(server) {
   server.tool(
     "platform_create_evaluator",
     `Create an evaluator on the LangWatch platform. Useful for setting up LLM-as-judge and other evaluators to use in evaluation notebooks. Call discover_schema({ category: 'evaluators' }) first to see available evaluator types and their settings.`,
@@ -1275,11 +1454,9 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     },
     withToolLogging("platform_create_evaluator", async (params) => {
       requireApiKey();
-      const { handleCreateEvaluator } = await import("./create-evaluator-JXF5PF33.js");
+      const { handleCreateEvaluator } = await import("./create-evaluator-643G6LXL.js");
       return {
-        content: [
-          { type: "text", text: await handleCreateEvaluator(params) }
-        ]
+        content: [{ type: "text", text: await handleCreateEvaluator(params) }]
       };
     })
   );
@@ -1289,7 +1466,7 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     {},
     withToolLogging("platform_list_evaluators", async () => {
       requireApiKey();
-      const { handleListEvaluators } = await import("./list-evaluators-SJHC7VBH.js");
+      const { handleListEvaluators } = await import("./list-evaluators-MYH2OVCI.js");
       return {
         content: [{ type: "text", text: await handleListEvaluators() }]
       };
@@ -1303,7 +1480,7 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     },
     withToolLogging("platform_get_evaluator", async (params) => {
       requireApiKey();
-      const { handleGetEvaluator } = await import("./get-evaluator-ADMKVWYZ.js");
+      const { handleGetEvaluator } = await import("./get-evaluator-ISMC4LLI.js");
       return {
         content: [{ type: "text", text: await handleGetEvaluator(params) }]
       };
@@ -1315,17 +1492,13 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     {
       evaluatorId: z2.string().describe("The evaluator ID to update"),
       name: z2.string().optional().describe("Updated evaluator name"),
-      config: z2.record(z2.string(), z2.unknown()).optional().describe(
-        "Updated config settings. Note: evaluatorType cannot be changed after creation."
-      )
+      config: z2.record(z2.string(), z2.unknown()).optional().describe("Updated config settings. Note: evaluatorType cannot be changed after creation.")
     },
     withToolLogging("platform_update_evaluator", async (params) => {
       requireApiKey();
-      const { handleUpdateEvaluator } = await import("./update-evaluator-LS6TIBY7.js");
+      const { handleUpdateEvaluator } = await import("./update-evaluator-IGTX6PX4.js");
       return {
-        content: [
-          { type: "text", text: await handleUpdateEvaluator(params) }
-        ]
+        content: [{ type: "text", text: await handleUpdateEvaluator(params) }]
       };
     })
   );
@@ -1337,19 +1510,19 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     },
     withToolLogging("platform_delete_evaluator", async (params) => {
       requireApiKey();
-      const { handleDeleteEvaluator } = await import("./delete-evaluator-33SP2JFX.js");
+      const { handleDeleteEvaluator } = await import("./delete-evaluator-4SNSCLEE.js");
       return {
         content: [{ type: "text", text: await handleDeleteEvaluator(params) }]
       };
     })
   );
+}
+function registerModelProviderTools(server) {
   server.tool(
     "platform_set_model_provider",
     `Set or update a model provider on the LangWatch platform. Use this to configure API keys (e.g. OPENAI_API_KEY) needed to run evaluators. The API key is stored securely and never returned in responses. Omit customKeys to update other settings without changing existing keys.`,
     {
-      provider: z2.string().describe(
-        'Provider name, e.g., "openai", "anthropic", "azure", "custom"'
-      ),
+      provider: z2.string().describe('Provider name, e.g., "openai", "anthropic", "azure", "custom"'),
       enabled: z2.boolean().describe("Whether the provider is enabled"),
       customKeys: z2.record(z2.string(), z2.unknown()).optional().describe(
         'API key configuration, e.g. { "OPENAI_API_KEY": "sk-..." }. Omit to keep existing keys.'
@@ -1358,11 +1531,9 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     },
     withToolLogging("platform_set_model_provider", async (params) => {
       requireApiKey();
-      const { handleSetModelProvider } = await import("./set-model-provider-3WKT63ZN.js");
+      const { handleSetModelProvider } = await import("./set-model-provider-GF7NXUJA.js");
       return {
-        content: [
-          { type: "text", text: await handleSetModelProvider(params) }
-        ]
+        content: [{ type: "text", text: await handleSetModelProvider(params) }]
       };
     })
   );
@@ -1372,19 +1543,21 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     {},
     withToolLogging("platform_list_model_providers", async () => {
       requireApiKey();
-      const { handleListModelProviders } = await import("./list-model-providers-PPD2WPD2.js");
+      const { handleListModelProviders } = await import("./list-model-providers-3JUGP4YI.js");
       return {
         content: [{ type: "text", text: await handleListModelProviders() }]
       };
     })
   );
+}
+function registerAgentTools(server) {
   server.tool(
     "platform_list_agents",
-    "List all agents in the LangWatch project with their names, types, and IDs.",
+    "List all agents in the LangWatch project with their names, types and IDs. A connected agent (one that registered itself from code with connectAgent or connect_agent) also shows its environment, whether it is online, how many instances are connected, and its owner.",
     {},
     withToolLogging("platform_list_agents", async () => {
       requireApiKey();
-      const { handleListAgents } = await import("./list-agents-KFHKGPXV.js");
+      const { handleListAgents } = await import("./list-agents-HVYWEQMI.js");
       return {
         content: [{ type: "text", text: await handleListAgents() }]
       };
@@ -1392,13 +1565,13 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
   );
   server.tool(
     "platform_get_agent",
-    "Get detailed information about a specific agent by its ID, including its configuration.",
+    "Get detailed information about a specific agent by its ID, including its configuration. A connected agent also shows its environment, status, the run parameters it declared (with options and defaults) and the instances connected right now.",
     {
       id: z2.string().describe("The agent ID")
     },
     withToolLogging("platform_get_agent", async (params) => {
       requireApiKey();
-      const { handleGetAgent } = await import("./get-agent-Y7MWZ65F.js");
+      const { handleGetAgent } = await import("./get-agent-OTIYUFZA.js");
       return {
         content: [{ type: "text", text: await handleGetAgent(params) }]
       };
@@ -1406,7 +1579,7 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
   );
   server.tool(
     "platform_create_agent",
-    "Create a new agent. Supported types: 'signature' (LLM prompt), 'code' (Python), 'workflow' (sub-workflow), 'http' (external API).",
+    "Create a new agent. Supported types: 'signature' (LLM prompt), 'code' (Python), 'workflow' (sub-workflow), 'http' (external API). A 'connected' agent is not created here: it registers itself from code, with connectAgent from langwatch/agent in TypeScript or langwatch.connect_agent in Python, and appears in the list once that process runs.",
     {
       name: z2.string().describe("Agent name"),
       type: z2.enum(["signature", "code", "workflow", "http"]).describe("Agent type"),
@@ -1414,10 +1587,12 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     },
     withToolLogging("platform_create_agent", async (params) => {
       requireApiKey();
-      const { handleCreateAgent } = await import("./create-agent-7XHO6UIS.js");
+      const { handleCreateAgent } = await import("./create-agent-AYZ3LB3V.js");
       const parsedConfig = params.config ? JSON.parse(params.config) : void 0;
       return {
-        content: [{ type: "text", text: await handleCreateAgent({ ...params, config: parsedConfig }) }]
+        content: [
+          { type: "text", text: await handleCreateAgent({ ...params, config: parsedConfig }) }
+        ]
       };
     })
   );
@@ -1432,10 +1607,12 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     },
     withToolLogging("platform_update_agent", async (params) => {
       requireApiKey();
-      const { handleUpdateAgent } = await import("./update-agent-SMAEHLXH.js");
+      const { handleUpdateAgent } = await import("./update-agent-DWG43T2P.js");
       const parsedConfig = params.config ? JSON.parse(params.config) : void 0;
       return {
-        content: [{ type: "text", text: await handleUpdateAgent({ ...params, config: parsedConfig }) }]
+        content: [
+          { type: "text", text: await handleUpdateAgent({ ...params, config: parsedConfig }) }
+        ]
       };
     })
   );
@@ -1447,7 +1624,7 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     },
     withToolLogging("platform_delete_agent", async (params) => {
       requireApiKey();
-      const { handleDeleteAgent } = await import("./delete-agent-O3EEH4S5.js");
+      const { handleDeleteAgent } = await import("./delete-agent-QMEK3XHK.js");
       return {
         content: [{ type: "text", text: await handleDeleteAgent(params) }]
       };
@@ -1455,26 +1632,46 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
   );
   server.tool(
     "platform_run_agent",
-    "Execute an agent with JSON input. HTTP agents call their configured URL directly; workflow-linked agents execute via the workflow engine.",
+    "Run one turn of an agent. A connected agent runs through the platform relay on a live instance: give `message` (one user turn) or `input` with a `messages` list, plus `parameters` and `threadId` to continue a conversation. HTTP agents call their configured URL directly; workflow-linked agents execute via the workflow engine.",
     {
       id: z2.string().describe("The agent ID to run"),
-      input: z2.string().optional().describe("Input data as a JSON object string")
+      input: z2.string().optional().describe(
+        "Input data as a JSON object string. For a connected agent it is the relay body: messages (OpenAI style), and optionally threadId, session and params."
+      ),
+      message: z2.string().optional().describe("One user message to send to a connected agent, instead of input"),
+      parameters: z2.record(z2.string(), z2.union([z2.string(), z2.number(), z2.boolean()])).optional().describe("Run parameter values for a connected agent, by name"),
+      threadId: z2.string().optional().describe("Continue a conversation on a connected agent")
     },
     withToolLogging("platform_run_agent", async (params) => {
       requireApiKey();
-      const { handleRunAgent } = await import("./run-agent-6SM4XNA7.js");
+      const { handleRunAgent } = await import("./run-agent-W4VJP72Z.js");
       return {
         content: [{ type: "text", text: await handleRunAgent(params) }]
       };
     })
   );
+  server.tool(
+    "platform_test_agent",
+    'Test an agent with one scripted scenario run: the user sends "ping", the agent answers, and the run succeeds when the answer arrives. No model is used, and no scenario, run plan or test suite is added to the project. Answers at once with the scenario run id to follow with platform_get_simulation_run; the run itself is asynchronous.',
+    {
+      id: z2.string().describe("The agent ID to test")
+    },
+    withToolLogging("platform_test_agent", async (params) => {
+      requireApiKey();
+      return {
+        content: [{ type: "text", text: await handleTestAgent(params) }]
+      };
+    })
+  );
+}
+function registerDashboardTools(server) {
   server.tool(
     "platform_list_dashboards",
     "List all analytics dashboards in the LangWatch project.",
     {},
     withToolLogging("platform_list_dashboards", async () => {
       requireApiKey();
-      const { handleListDashboards } = await import("./list-dashboards-PWG6P6KR.js");
+      const { handleListDashboards } = await import("./list-dashboards-ROSYFLDQ.js");
       return {
         content: [{ type: "text", text: await handleListDashboards() }]
       };
@@ -1488,7 +1685,7 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     },
     withToolLogging("platform_get_dashboard", async (params) => {
       requireApiKey();
-      const { handleGetDashboard } = await import("./get-dashboard-KHBEGZGL.js");
+      const { handleGetDashboard } = await import("./get-dashboard-QMTYDQAZ.js");
       return {
         content: [{ type: "text", text: await handleGetDashboard(params) }]
       };
@@ -1502,7 +1699,7 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     },
     withToolLogging("platform_create_dashboard", async (params) => {
       requireApiKey();
-      const { handleCreateDashboard } = await import("./create-dashboard-4Z5JO5LB.js");
+      const { handleCreateDashboard } = await import("./create-dashboard-WTKKS5Z6.js");
       return {
         content: [{ type: "text", text: await handleCreateDashboard(params) }]
       };
@@ -1516,7 +1713,7 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     },
     withToolLogging("platform_delete_dashboard", async (params) => {
       requireApiKey();
-      const { handleDeleteDashboard } = await import("./delete-dashboard-RFUNYCNP.js");
+      const { handleDeleteDashboard } = await import("./delete-dashboard-JVIVHNJM.js");
       return {
         content: [{ type: "text", text: await handleDeleteDashboard(params) }]
       };
@@ -1531,20 +1728,99 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     },
     withToolLogging("platform_rename_dashboard", async (params) => {
       requireApiKey();
-      const { renameDashboard } = await import("./langwatch-api-dashboards-JTVCS7ZJ.js");
+      const { renameDashboard } = await import("./langwatch-api-dashboards-NHU5BZD7.js");
       const result = await renameDashboard(params.id, { name: params.name });
       return {
-        content: [{ type: "text", text: `Dashboard "${result.name}" renamed successfully (ID: ${result.id}).` }]
+        content: [
+          {
+            type: "text",
+            text: `Dashboard "${result.name}" renamed successfully (ID: ${result.id}).`
+          }
+        ]
+      };
+    })
+  );
+  server.tool(
+    "list_dashboard_boards",
+    "Lists the project's boards in the Dashboards area, with each one's ID and widget count. Use an ID from here as the dashboardId of add_dashboard_widget and update_dashboard_widget; the analytics dashboards platform_list_dashboards lists hold no widgets.",
+    {},
+    withToolLogging("list_dashboard_boards", async () => {
+      requireApiKey();
+      const { handleListDashboardBoards } = await import("./list-dashboard-boards-U2GJ7GC5.js");
+      return {
+        content: [{ type: "text", text: await handleListDashboardBoards() }]
+      };
+    })
+  );
+  server.tool(
+    "add_dashboard_widget",
+    "Creates a custom dashboard widget and places it on the given dashboard. A widget's `code` is a TSX file run in a sandbox: it receives a global `LW` with `LW.useChartQuery(name)` (reads one of the widget's own named queries), `LW.navigate` and `LW.theme`. `queries` are named LangWatchQL SQL statements the code can read by name \u2014 validate each statement's SQL first with run_query before calling this tool, since a query only runs inside the sandbox at render time and a mistake surfaces there, not here. Up to 8 queries per widget.",
+    {
+      dashboardId: z2.string().describe("The Dashboards board to add the widget to, as list_dashboard_boards lists it"),
+      name: z2.string().describe("The widget's display name"),
+      code: z2.string().describe(
+        "The widget's TSX source. Runs sandboxed with a global LW (LW.useChartQuery(name), LW.navigate, LW.theme) in scope."
+      ),
+      queries: z2.union([
+        z2.record(z2.string(), z2.string()).describe('{"<name>": "<LWQL SQL>"}'),
+        z2.array(
+          z2.object({
+            name: z2.string().describe('Referenced from code as LW.useChartQuery("name")'),
+            sql: z2.string().describe("The LangWatchQL statement")
+          })
+        ).describe("Named LWQL queries, array form")
+      ]).describe(
+        "The widget's named LangWatchQL queries: either {name: sql} or an array of {name, sql}. Max 8. Validate each statement with run_query first."
+      )
+    },
+    withToolLogging("add_dashboard_widget", async (params) => {
+      requireApiKey();
+      const { handleAddDashboardWidget } = await import("./add-dashboard-widget-4ZC5UN73.js");
+      return {
+        content: [{ type: "text", text: await handleAddDashboardWidget(params) }]
+      };
+    })
+  );
+  server.tool(
+    "update_dashboard_widget",
+    "Changes one custom widget on a dashboard: its name, its TSX `code`, its named LangWatchQL `queries` or its `description`. Pass only the fields to change; every field left out keeps its stored value. Validate any new query's SQL with run_query first. Returns the updated widget.",
+    {
+      dashboardId: z2.string().describe("The dashboard the widget is on"),
+      widgetId: z2.string().describe("The widget to change, as add_dashboard_widget returned it"),
+      name: z2.string().optional().describe("The widget's new display name"),
+      code: z2.string().optional().describe(
+        "The widget's new TSX source. Runs sandboxed with a global LW (LW.useChartQuery(name), LW.navigate, LW.theme) in scope."
+      ),
+      queries: z2.union([
+        z2.record(z2.string(), z2.string()).describe('{"<name>": "<LWQL SQL>"}'),
+        z2.array(
+          z2.object({
+            name: z2.string().describe('Referenced from code as LW.useChartQuery("name")'),
+            sql: z2.string().describe("The LangWatchQL statement")
+          })
+        ).describe("Named LWQL queries, array form")
+      ]).optional().describe(
+        "The widget's new named LangWatchQL queries, replacing the stored set: either {name: sql} or an array of {name, sql}. Max 8."
+      ),
+      description: z2.string().optional().describe("What the widget's info tip says: a sentence or two")
+    },
+    withToolLogging("update_dashboard_widget", async (params) => {
+      requireApiKey();
+      const { handleUpdateDashboardWidget } = await import("./update-dashboard-widget-CJKJLCDY.js");
+      return {
+        content: [{ type: "text", text: await handleUpdateDashboardWidget(params) }]
       };
     })
   );
+}
+function registerWorkflowTools(server) {
   server.tool(
     "platform_list_workflows",
     "List all workflows in the LangWatch project.",
     {},
     withToolLogging("platform_list_workflows", async () => {
       requireApiKey();
-      const { handleListWorkflows } = await import("./list-workflows-QSJWURCK.js");
+      const { handleListWorkflows } = await import("./list-workflows-IMSX7SXU.js");
       return {
         content: [{ type: "text", text: await handleListWorkflows() }]
       };
@@ -1558,7 +1834,7 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     },
     withToolLogging("platform_get_workflow", async (params) => {
       requireApiKey();
-      const { handleGetWorkflow } = await import("./get-workflow-L5L2PSK3.js");
+      const { handleGetWorkflow } = await import("./get-workflow-YXULW4GC.js");
       return {
         content: [{ type: "text", text: await handleGetWorkflow(params) }]
       };
@@ -1572,7 +1848,7 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     },
     withToolLogging("platform_delete_workflow", async (params) => {
       requireApiKey();
-      const { handleDeleteWorkflow } = await import("./delete-workflow-3NUXO46U.js");
+      const { handleDeleteWorkflow } = await import("./delete-workflow-5J46T73T.js");
       return {
         content: [{ type: "text", text: await handleDeleteWorkflow(params) }]
       };
@@ -1587,12 +1863,14 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     },
     withToolLogging("platform_run_workflow", async (params) => {
       requireApiKey();
-      const { handleRunWorkflow } = await import("./run-workflow-QPXC627O.js");
+      const { handleRunWorkflow } = await import("./run-workflow-D6PQNBI6.js");
       return {
         content: [{ type: "text", text: await handleRunWorkflow(params) }]
       };
     })
   );
+}
+function registerAnnotationTools(server) {
   server.tool(
     "platform_list_annotations",
     "List all annotations for the project, optionally filtered by trace ID.",
@@ -1601,7 +1879,7 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     },
     withToolLogging("platform_list_annotations", async (params) => {
       requireApiKey();
-      const { handleListAnnotations } = await import("./list-annotations-ZTVP4EEL.js");
+      const { handleListAnnotations } = await import("./list-annotations-J4UAHSUN.js");
       return {
         content: [{ type: "text", text: await handleListAnnotations(params) }]
       };
@@ -1618,7 +1896,7 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     },
     withToolLogging("platform_create_annotation", async (params) => {
       requireApiKey();
-      const { handleCreateAnnotation } = await import("./create-annotation-YQXRQC6A.js");
+      const { handleCreateAnnotation } = await import("./create-annotation-VUSXULQK.js");
       return {
         content: [{ type: "text", text: await handleCreateAnnotation(params) }]
       };
@@ -1632,7 +1910,7 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     },
     withToolLogging("platform_delete_annotation", async (params) => {
       requireApiKey();
-      const { handleDeleteAnnotation } = await import("./delete-annotation-XP6FQM7A.js");
+      const { handleDeleteAnnotation } = await import("./delete-annotation-VKIQWUYW.js");
       return {
         content: [{ type: "text", text: await handleDeleteAnnotation(params) }]
       };
@@ -1646,7 +1924,7 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     },
     withToolLogging("platform_get_annotation", async (params) => {
       requireApiKey();
-      const { getAnnotation } = await import("./langwatch-api-annotations-FDAS6NQ7.js");
+      const { getAnnotation } = await import("./langwatch-api-annotations-TBHLCQ5R.js");
       const annotation = await getAnnotation(params.id);
       const lines = [
         `**ID**: ${annotation.id}`,
@@ -1660,6 +1938,8 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
       };
     })
   );
+}
+function registerTriggerTools(server) {
   server.tool(
     "platform_list_triggers",
     "List all triggers (automations) in the project. Triggers automate actions like sending emails, Slack messages, or adding to datasets when conditions are met.",
@@ -1668,73 +1948,128 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     },
     withToolLogging("platform_list_triggers", async (params) => {
       requireApiKey();
-      const { listTriggers } = await import("./langwatch-api-triggers-EDFUCJN6.js");
-      const triggers = await listTriggers();
-      if (params.format === "json") {
-        return { content: [{ type: "text", text: JSON.stringify(triggers, null, 2) }] };
-      }
-      if (triggers.length === 0) {
-        return { content: [{ type: "text", text: "No triggers found. Use `platform_create_trigger` to create one." }] };
-      }
-      const lines = [`# Triggers (${triggers.length} total)
-`];
-      for (const t of triggers) {
-        lines.push(`## ${t.name}`);
-        lines.push(`**ID**: ${t.id}`);
-        lines.push(`**Action**: ${t.action}`);
-        lines.push(`**Status**: ${t.active ? "active" : "inactive"}`);
-        if (t.alertType) lines.push(`**Alert**: ${t.alertType}`);
-        lines.push("");
-      }
-      return { content: [{ type: "text", text: lines.join("\n") }] };
+      const { handleListTriggers } = await import("./list-triggers-V4Y356AK.js");
+      return { content: [{ type: "text", text: await handleListTriggers(params) }] };
+    })
+  );
+  server.tool(
+    "platform_get_trigger",
+    "Read one trigger (automation) by its ID, including its delivery configuration. Credential values come back as [redacted]; sending them back unchanged on an update keeps the stored values.",
+    {
+      id: z2.string().describe("The trigger ID")
+    },
+    withToolLogging("platform_get_trigger", async (params) => {
+      requireApiKey();
+      const { getTrigger } = await import("./langwatch-api-triggers-QS7HDIVW.js");
+      const trigger = await getTrigger(params.id);
+      return { content: [{ type: "text", text: JSON.stringify(trigger, null, 2) }] };
     })
   );
   server.tool(
     "platform_create_trigger",
-    "Create a new trigger (automation) that fires when conditions are met.",
+    [
+      "Create a trigger (automation).",
+      "",
+      "It is about one of three things: matching traces (send `filters` or `filterQuery`), a metric crossing a threshold on a graph (an Alert: send `customGraphId`, `graphAlert` and `alertType`), or a schedule (a Report: send `report`, on an email or Slack channel).",
+      "`actionParams` is the delivery configuration for the channel named in `action` \u2014 recipients for SEND_EMAIL, a destination for SEND_SLACK_MESSAGE, a URL for SEND_WEBHOOK, a dataset and mapping for ADD_TO_DATASET, annotators for ADD_TO_ANNOTATION_QUEUE. Omitted, it is sent as {} and the server refuses a channel that cannot deliver without one.",
+      SLACK_DELIVERY_NOTE,
+      `filters: ${TRIGGER_FILTERS_DESCRIPTION}`,
+      "The delivery channel cannot be changed afterwards."
+    ].join("\n"),
     {
       name: z2.string().describe("Trigger name"),
-      action: z2.enum(["SEND_EMAIL", "ADD_TO_DATASET", "ADD_TO_ANNOTATION_QUEUE", "SEND_SLACK_MESSAGE"]).describe("Action to take when triggered"),
-      filters: z2.string().optional().describe("Filter conditions as JSON string"),
+      action: triggerActionSchema.describe("Which channel it delivers on"),
+      actionParams: actionParamsSchema.optional().describe("The delivery configuration the channel named in `action` reads. Defaults to {}"),
+      filters: z2.string().optional().describe(TRIGGER_FILTERS_DESCRIPTION),
+      filterQuery: z2.string().optional().describe(TRIGGER_FILTER_QUERY_DESCRIPTION),
+      customGraphId: z2.string().optional().describe("Set to make this an alert on that graph"),
+      graphAlert: graphAlertSchema.optional(),
+      report: reportSchema.optional().describe("Set to make this a scheduled report"),
+      templates: templatesSchema.optional(),
+      notificationCadence: notificationCadenceSchema.optional(),
       message: z2.string().optional().describe("Custom alert message"),
-      alertType: z2.enum(["CRITICAL", "WARNING", "INFO"]).optional().describe("Alert severity")
+      alertType: alertTypeSchema.optional().describe("Alert severity. Required for a graph alert.")
     },
     withToolLogging("platform_create_trigger", async (params) => {
       requireApiKey();
-      const { createTrigger } = await import("./langwatch-api-triggers-EDFUCJN6.js");
-      let filters = {};
-      if (params.filters) {
-        try {
-          filters = JSON.parse(params.filters);
-        } catch {
-          return { content: [{ type: "text", text: "Error: filters must be valid JSON" }] };
-        }
-      }
-      const trigger = await createTrigger({
-        name: params.name,
-        action: params.action,
-        filters,
-        message: params.message,
-        alertType: params.alertType
-      });
-      return { content: [{ type: "text", text: `Trigger "${trigger.name}" created (ID: ${trigger.id}, Action: ${trigger.action}).` }] };
+      const { handleCreateTrigger } = await import("./create-trigger-5HZSCRAN.js");
+      return handleCreateTrigger(params);
     })
   );
   server.tool(
     "platform_update_trigger",
-    "Update a trigger (name, active state, message, alert type).",
+    [
+      "Update a trigger (automation). Anything left out is left alone.",
+      "",
+      "`actionParams` replaces the delivery configuration as a whole, so send every field it should have from now on. A credential the read hid comes back as [redacted]; send that back to keep the stored value. Changing a webhook's `url` means sending its header values in the same call.",
+      "The delivery channel, the kind of automation and an alert's graph cannot be changed."
+    ].join("\n"),
     {
       id: z2.string().describe("The trigger ID"),
       name: z2.string().optional().describe("New name"),
-      active: z2.boolean().optional().describe("Enable or disable"),
-      message: z2.string().optional().describe("New alert message"),
-      alertType: z2.enum(["CRITICAL", "WARNING", "INFO"]).optional().describe("New alert severity")
+      active: z2.boolean().optional().describe("Resume or pause it"),
+      actionParams: actionParamsSchema.optional().describe("The delivery configuration this automation should have from now on"),
+      filters: z2.string().optional().describe(TRIGGER_FILTERS_DESCRIPTION),
+      filterQuery: z2.string().nullable().optional().describe(`${TRIGGER_FILTER_QUERY_DESCRIPTION} null clears the saved query.`),
+      graphAlert: graphAlertSchema.optional().describe("Only for an automation that is already a graph alert"),
+      report: reportSchema.optional().describe("Only for an automation that is already a scheduled report"),
+      templates: templatesSchema.optional(),
+      notificationCadence: notificationCadenceSchema.optional(),
+      message: z2.string().nullable().optional().describe("New alert message. null removes the custom message"),
+      alertType: alertTypeSchema.nullable().optional().describe("New alert severity. null clears it")
     },
     withToolLogging("platform_update_trigger", async (params) => {
       requireApiKey();
-      const { updateTrigger } = await import("./langwatch-api-triggers-EDFUCJN6.js");
-      const trigger = await updateTrigger(params);
-      return { content: [{ type: "text", text: `Trigger "${trigger.name}" updated (active: ${trigger.active}).` }] };
+      const { getTrigger, updateTrigger } = await import("./langwatch-api-triggers-QS7HDIVW.js");
+      if (params.actionParams !== void 0) {
+        const saved = await getTrigger(params.id);
+        const boundParams = validateActionParamsForAction({
+          action: saved.action,
+          actionParams: params.actionParams
+        });
+        if (!boundParams.ok) {
+          const { toolError: toolError2 } = await import("./create-trigger-5HZSCRAN.js");
+          return toolError2(boundParams.message);
+        }
+      }
+      const { parseJsonObject, toolError } = await import("./create-trigger-5HZSCRAN.js");
+      const filters = params.filters ? parseJsonObject(params.filters) : void 0;
+      if (params.filters && !filters) {
+        return toolError("filters must be a JSON object");
+      }
+      const trigger = await updateTrigger({ ...params, filters });
+      return {
+        content: [
+          { type: "text", text: `Trigger "${trigger.name}" updated (active: ${trigger.active}).` }
+        ]
+      };
+    })
+  );
+  server.tool(
+    "platform_test_fire_trigger",
+    "Send a trigger's message to the destination it is configured with, to confirm it arrives. Nothing is recorded as a fire.",
+    {
+      id: z2.string().describe("The trigger ID")
+    },
+    withToolLogging("platform_test_fire_trigger", async (params) => {
+      requireApiKey();
+      const { testFireTrigger } = await import("./langwatch-api-triggers-QS7HDIVW.js");
+      const result = await testFireTrigger(params.id);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    })
+  );
+  server.tool(
+    "platform_list_trigger_fires",
+    "What an automation has done, newest first. Metadata only \u2014 no message content. Answers with `nextCursor`; pass it back as `cursor` for the next page (null means there is none).",
+    {
+      id: z2.string().describe("The trigger ID"),
+      limit: z2.number().int().positive().optional().describe("How many fires to return"),
+      cursor: z2.string().optional().describe("The `nextCursor` a previous call answered with")
+    },
+    withToolLogging("platform_list_trigger_fires", async (params) => {
+      requireApiKey();
+      const { handleListTriggerFires } = await import("./list-trigger-fires-WTW4DVIW.js");
+      return { content: [{ type: "text", text: await handleListTriggerFires(params) }] };
     })
   );
   server.tool(
@@ -1745,18 +2080,20 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     },
     withToolLogging("platform_delete_trigger", async (params) => {
       requireApiKey();
-      const { deleteTrigger } = await import("./langwatch-api-triggers-EDFUCJN6.js");
+      const { deleteTrigger } = await import("./langwatch-api-triggers-QS7HDIVW.js");
       const result = await deleteTrigger(params.id);
       return { content: [{ type: "text", text: `Trigger ${result.id} deleted.` }] };
     })
   );
+}
+function registerMonitorTools(server) {
   server.tool(
     "platform_list_monitors",
     "List all online evaluation monitors for the project.",
     {},
     withToolLogging("platform_list_monitors", async () => {
       requireApiKey();
-      const { listMonitors } = await import("./langwatch-api-monitors-3J7UIQME.js");
+      const { listMonitors } = await import("./langwatch-api-monitors-YNWA2M5Y.js");
       const monitors = await listMonitors();
       if (monitors.length === 0) {
         return { content: [{ type: "text", text: "No monitors found." }] };
@@ -1783,7 +2120,7 @@ ${lines.join("\n")}`
     },
     withToolLogging("platform_get_monitor", async (params) => {
       requireApiKey();
-      const { getMonitor } = await import("./langwatch-api-monitors-3J7UIQME.js");
+      const { getMonitor } = await import("./langwatch-api-monitors-YNWA2M5Y.js");
       const m = await getMonitor(params.id);
       const lines = [
         `**${m.name}** (${m.id})`,
@@ -1810,7 +2147,7 @@ ${lines.join("\n")}`
     },
     withToolLogging("platform_create_monitor", async (params) => {
       requireApiKey();
-      const { createMonitor } = await import("./langwatch-api-monitors-3J7UIQME.js");
+      const { createMonitor } = await import("./langwatch-api-monitors-YNWA2M5Y.js");
       const monitor = await createMonitor(params);
       return {
         content: [
@@ -1834,7 +2171,7 @@ ${lines.join("\n")}`
     },
     withToolLogging("platform_update_monitor", async (params) => {
       requireApiKey();
-      const { updateMonitor } = await import("./langwatch-api-monitors-3J7UIQME.js");
+      const { updateMonitor } = await import("./langwatch-api-monitors-YNWA2M5Y.js");
       const monitor = await updateMonitor(params);
       return {
         content: [
@@ -1854,29 +2191,27 @@ ${lines.join("\n")}`
     },
     withToolLogging("platform_delete_monitor", async (params) => {
       requireApiKey();
-      const { deleteMonitor } = await import("./langwatch-api-monitors-3J7UIQME.js");
+      const { deleteMonitor } = await import("./langwatch-api-monitors-YNWA2M5Y.js");
       const result = await deleteMonitor(params.id);
       return {
-        content: [
-          { type: "text", text: `Monitor ${result.id} deleted.` }
-        ]
+        content: [{ type: "text", text: `Monitor ${result.id} deleted.` }]
       };
     })
   );
+}
+function registerSecretTools(server) {
   server.tool(
     "platform_list_secrets",
     "List all project secrets (values are never returned, only metadata).",
     {},
     withToolLogging("platform_list_secrets", async () => {
       requireApiKey();
-      const { listSecrets } = await import("./langwatch-api-secrets-BUBSNCNO.js");
+      const { listSecrets } = await import("./langwatch-api-secrets-ADTOJELP.js");
       const secrets = await listSecrets();
       if (secrets.length === 0) {
         return { content: [{ type: "text", text: "No secrets found." }] };
       }
-      const lines = secrets.map(
-        (s) => `\u2022 ${s.name} (id: ${s.id}, updated: ${s.updatedAt})`
-      );
+      const lines = secrets.map((s) => `\u2022 ${s.name} (id: ${s.id}, updated: ${s.updatedAt})`);
       return {
         content: [
           {
@@ -1897,7 +2232,7 @@ ${lines.join("\n")}`
     },
     withToolLogging("platform_create_secret", async (params) => {
       requireApiKey();
-      const { createSecret } = await import("./langwatch-api-secrets-BUBSNCNO.js");
+      const { createSecret } = await import("./langwatch-api-secrets-ADTOJELP.js");
       const secret = await createSecret({ name: params.name, value: params.value });
       return {
         content: [
@@ -1918,7 +2253,7 @@ ${lines.join("\n")}`
     },
     withToolLogging("platform_update_secret", async (params) => {
       requireApiKey();
-      const { updateSecret } = await import("./langwatch-api-secrets-BUBSNCNO.js");
+      const { updateSecret } = await import("./langwatch-api-secrets-ADTOJELP.js");
       const secret = await updateSecret({ id: params.id, value: params.value });
       return {
         content: [
@@ -1938,11 +2273,13 @@ ${lines.join("\n")}`
     },
     withToolLogging("platform_delete_secret", async (params) => {
       requireApiKey();
-      const { deleteSecret } = await import("./langwatch-api-secrets-BUBSNCNO.js");
+      const { deleteSecret } = await import("./langwatch-api-secrets-ADTOJELP.js");
       const result = await deleteSecret(params.id);
       return { content: [{ type: "text", text: `Secret ${result.id} deleted.` }] };
     })
   );
+}
+function registerExperimentTools(server) {
   server.tool(
     "platform_run_experiment",
     "Start an experiment run by slug. Returns a run ID for polling status.",
@@ -1976,9 +2313,7 @@ ${lines.join("\n")}`
     "platform_experiment_list",
     "List experiments configured in the LangWatch project. Returns a markdown table with each experiment's slug, name, last-run timestamp, and run count. Use this to discover experiment slugs before drilling into runs with platform_experiment_list_runs. Output is capped (default 25, max 100) to protect the agent's context window.",
     {
-      limit: z2.number().int().positive().max(100).optional().describe(
-        "Maximum number of experiments to include (default 25, hard-capped at 100)"
-      )
+      limit: z2.number().int().positive().max(100).optional().describe("Maximum number of experiments to include (default 25, hard-capped at 100)")
     },
     withToolLogging("platform_experiment_list", async (params) => {
       requireApiKey();
@@ -1991,12 +2326,8 @@ ${lines.join("\n")}`
     "platform_experiment_list_runs",
     "List experiment runs for a specific experiment slug. Returns a markdown table with each run's id, status, started/finished timestamps, and pass-rate summary. Use this to discover run ids before calling platform_experiment_results. Output is capped (default 25, max 100) to protect the agent's context window.",
     {
-      experimentSlug: z2.string().describe(
-        "Experiment slug from platform_experiment_list (e.g. 'checkout-flow')"
-      ),
-      limit: z2.number().int().positive().max(100).optional().describe(
-        "Maximum number of runs to include (default 25, hard-capped at 100)"
-      )
+      experimentSlug: z2.string().describe("Experiment slug from platform_experiment_list (e.g. 'checkout-flow')"),
+      limit: z2.number().int().positive().max(100).optional().describe("Maximum number of runs to include (default 25, hard-capped at 100)")
     },
     withToolLogging("platform_experiment_list_runs", async (params) => {
       requireApiKey();
@@ -2024,24 +2355,22 @@ ${lines.join("\n")}`
     withToolLogging("platform_experiment_results", async (params) => {
       requireApiKey();
       return {
-        content: [
-          { type: "text", text: await handleExperimentResults(params) }
-        ]
+        content: [{ type: "text", text: await handleExperimentResults(params) }]
       };
     })
   );
+}
+function registerDatasetTools(server) {
   server.tool(
     "platform_list_datasets",
     "List all datasets on the LangWatch platform with their names, slugs, columns, and record counts. Returns AI-readable digest by default.",
     {
-      format: z2.enum(["digest", "json"]).optional().describe(
-        "Output format: 'digest' (default, AI-readable) or 'json' (full raw data)"
-      )
+      format: z2.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
     },
     async (params) => {
-      const { requireApiKey: requireApiKey2 } = await import("./config.js");
+      const { requireApiKey: requireApiKey2 } = await import("./config-EAKW6F26.js");
       requireApiKey2();
-      const { handleListDatasets } = await import("./list-datasets-ZT4JYUDT.js");
+      const { handleListDatasets } = await import("./list-datasets-B5X4P7BQ.js");
       return {
         content: [{ type: "text", text: await handleListDatasets(params) }]
       };
@@ -2052,14 +2381,12 @@ ${lines.join("\n")}`
     "Get full details of a dataset on the LangWatch platform by slug or ID, including column definitions and a preview of records.",
     {
       slugOrId: z2.string().describe("The dataset slug or ID to retrieve"),
-      format: z2.enum(["digest", "json"]).optional().describe(
-        "Output format: 'digest' (default, AI-readable) or 'json' (full raw data)"
-      )
+      format: z2.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
     },
     async (params) => {
-      const { requireApiKey: requireApiKey2 } = await import("./config.js");
+      const { requireApiKey: requireApiKey2 } = await import("./config-EAKW6F26.js");
       requireApiKey2();
-      const { handleGetDataset } = await import("./get-dataset-RCMU5VAH.js");
+      const { handleGetDataset } = await import("./get-dataset-ALSP7RTX.js");
       return {
         content: [{ type: "text", text: await handleGetDataset(params) }]
       };
@@ -2070,9 +2397,9 @@ ${lines.join("\n")}`
     "Create a new dataset on the LangWatch platform.",
     createDatasetSchema.shape,
     async (params) => {
-      const { requireApiKey: requireApiKey2 } = await import("./config.js");
+      const { requireApiKey: requireApiKey2 } = await import("./config-EAKW6F26.js");
       requireApiKey2();
-      const { handleCreateDataset } = await import("./create-dataset-E6NMSVX7.js");
+      const { handleCreateDataset } = await import("./create-dataset-2MC4SD4O.js");
       return {
         content: [{ type: "text", text: await handleCreateDataset(params) }]
       };
@@ -2087,9 +2414,9 @@ ${lines.join("\n")}`
       columnTypes: z2.array(datasetColumnDefinitionSchema).optional().describe("Updated column definitions")
     },
     async (params) => {
-      const { requireApiKey: requireApiKey2 } = await import("./config.js");
+      const { requireApiKey: requireApiKey2 } = await import("./config-EAKW6F26.js");
       requireApiKey2();
-      const { handleUpdateDataset } = await import("./update-dataset-BDUK7TUO.js");
+      const { handleUpdateDataset } = await import("./update-dataset-SQZ6T4WX.js");
       return {
         content: [{ type: "text", text: await handleUpdateDataset(params) }]
       };
@@ -2102,9 +2429,9 @@ ${lines.join("\n")}`
       slugOrId: z2.string().describe("The dataset slug or ID to delete")
     },
     async (params) => {
-      const { requireApiKey: requireApiKey2 } = await import("./config.js");
+      const { requireApiKey: requireApiKey2 } = await import("./config-EAKW6F26.js");
       requireApiKey2();
-      const { handleDeleteDataset } = await import("./delete-dataset-3MJFRDLP.js");
+      const { handleDeleteDataset } = await import("./delete-dataset-WKRUW4FP.js");
       return {
         content: [{ type: "text", text: await handleDeleteDataset(params) }]
       };
@@ -2120,13 +2447,11 @@ ${lines.join("\n")}`
       format: z2.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
     },
     async (params) => {
-      const { requireApiKey: requireApiKey2 } = await import("./config.js");
+      const { requireApiKey: requireApiKey2 } = await import("./config-EAKW6F26.js");
       requireApiKey2();
-      const { handleListDatasetRecords } = await import("./list-dataset-records-IOE7LQXS.js");
+      const { handleListDatasetRecords } = await import("./list-dataset-records-M5TKA6LK.js");
       return {
-        content: [
-          { type: "text", text: await handleListDatasetRecords(params) }
-        ]
+        content: [{ type: "text", text: await handleListDatasetRecords(params) }]
       };
     }
   );
@@ -2138,13 +2463,11 @@ ${lines.join("\n")}`
       entries: z2.array(z2.record(z2.string(), z2.unknown())).min(1).max(1e3).describe("Array of record entries to create (key-value objects matching dataset columns)")
     },
     async (params) => {
-      const { requireApiKey: requireApiKey2 } = await import("./config.js");
+      const { requireApiKey: requireApiKey2 } = await import("./config-EAKW6F26.js");
       requireApiKey2();
-      const { handleCreateDatasetRecords } = await import("./create-dataset-records-SKHPRD2K.js");
+      const { handleCreateDatasetRecords } = await import("./create-dataset-records-W4GLN2FV.js");
       return {
-        content: [
-          { type: "text", text: await handleCreateDatasetRecords(params) }
-        ]
+        content: [{ type: "text", text: await handleCreateDatasetRecords(params) }]
       };
     }
   );
@@ -2157,13 +2480,11 @@ ${lines.join("\n")}`
       entry: z2.record(z2.string(), z2.unknown()).describe("Updated record entry (key-value object)")
     },
     async (params) => {
-      const { requireApiKey: requireApiKey2 } = await import("./config.js");
+      const { requireApiKey: requireApiKey2 } = await import("./config-EAKW6F26.js");
       requireApiKey2();
-      const { handleUpdateDatasetRecord } = await import("./update-dataset-record-4ZSDRBSW.js");
+      const { handleUpdateDatasetRecord } = await import("./update-dataset-record-3AT4IPBC.js");
       return {
-        content: [
-          { type: "text", text: await handleUpdateDatasetRecord(params) }
-        ]
+        content: [{ type: "text", text: await handleUpdateDatasetRecord(params) }]
       };
     }
   );
@@ -2175,16 +2496,16 @@ ${lines.join("\n")}`
       recordIds: z2.array(z2.string()).min(1).max(1e3).describe("Array of record IDs to delete")
     },
     async (params) => {
-      const { requireApiKey: requireApiKey2 } = await import("./config.js");
+      const { requireApiKey: requireApiKey2 } = await import("./config-EAKW6F26.js");
       requireApiKey2();
-      const { handleDeleteDatasetRecords } = await import("./delete-dataset-records-WPMU5GL5.js");
+      const { handleDeleteDatasetRecords } = await import("./delete-dataset-records-C2IQFFVQ.js");
       return {
-        content: [
-          { type: "text", text: await handleDeleteDatasetRecords(params) }
-        ]
+        content: [{ type: "text", text: await handleDeleteDatasetRecords(params) }]
       };
     }
   );
+}
+function registerProjectTools(server) {
   server.tool(
     "platform_list_projects",
     "List all projects in your LangWatch organization. Requires an org-level API key.",
@@ -2194,7 +2515,7 @@ ${lines.join("\n")}`
     },
     withToolLogging("platform_list_projects", async (params) => {
       requireApiKey();
-      const { handleListProjects } = await import("./list-projects-K7QAIX2I.js");
+      const { handleListProjects } = await import("./list-projects-6EJ5YYEW.js");
       return {
         content: [{ type: "text", text: await handleListProjects(params) }]
       };
@@ -2208,7 +2529,7 @@ ${lines.join("\n")}`
     },
     withToolLogging("platform_get_project", async (params) => {
       requireApiKey();
-      const { handleGetProject } = await import("./get-project-RAK7URQJ.js");
+      const { handleGetProject } = await import("./get-project-5VKROSDH.js");
       return {
         content: [{ type: "text", text: await handleGetProject(params) }]
       };
@@ -2228,7 +2549,7 @@ You must provide either teamId (to add the project to an existing team) or newTe
     },
     withToolLogging("platform_create_project", async (params) => {
       requireApiKey();
-      const { handleCreateProject } = await import("./create-project-CS2CB57Y.js");
+      const { handleCreateProject } = await import("./create-project-KAIC46UY.js");
       return {
         content: [{ type: "text", text: await handleCreateProject(params) }]
       };
@@ -2246,7 +2567,7 @@ You must provide either teamId (to add the project to an existing team) or newTe
     },
     withToolLogging("platform_update_project", async (params) => {
       requireApiKey();
-      const { handleUpdateProject } = await import("./update-project-LKVYXENH.js");
+      const { handleUpdateProject } = await import("./update-project-PLJIOZS6.js");
       return {
         content: [{ type: "text", text: await handleUpdateProject(params) }]
       };
@@ -2260,19 +2581,21 @@ You must provide either teamId (to add the project to an existing team) or newTe
     },
     withToolLogging("platform_archive_project", async (params) => {
       requireApiKey();
-      const { handleArchiveProject } = await import("./archive-project-4EQGLBJJ.js");
+      const { handleArchiveProject } = await import("./archive-project-SPVHXK6A.js");
       return {
         content: [{ type: "text", text: await handleArchiveProject(params) }]
       };
     })
   );
+}
+function registerApiKeyTools(server) {
   server.tool(
     "platform_list_api_keys",
     "List all API keys in your LangWatch organization. Shows key metadata, status (active/revoked/expired), and role bindings. API key tokens are never returned.",
     {},
     withToolLogging("platform_list_api_keys", async () => {
       requireApiKey();
-      const { handleListApiKeys } = await import("./list-api-keys-CWD4UQT5.js");
+      const { handleListApiKeys } = await import("./list-api-keys-7UTJRZDG.js");
       return {
         content: [{ type: "text", text: await handleListApiKeys() }]
       };
@@ -2291,16 +2614,18 @@ The token is returned once and cannot be retrieved again.`,
       name: z2.string().describe("Key name (max 100 chars)"),
       description: z2.string().optional().describe("Key description (max 500 chars)"),
       expiresAt: z2.string().optional().describe("Expiration date (ISO string)"),
-      bindings: z2.array(z2.object({
-        role: z2.enum(["ADMIN", "MEMBER", "VIEWER"]).describe("Role"),
-        scopeType: z2.enum(["ORGANIZATION", "TEAM", "PROJECT"]).describe("Scope type"),
-        scopeId: z2.string().describe("Scope ID (org, team, or project ID)")
-      })).optional().describe("Role bindings (required for personal keys)"),
+      bindings: z2.array(
+        z2.object({
+          role: z2.enum(["ADMIN", "MEMBER", "VIEWER"]).describe("Role"),
+          scopeType: z2.enum(["ORGANIZATION", "TEAM", "PROJECT"]).describe("Scope type"),
+          scopeId: z2.string().describe("Scope ID (org, team, or project ID)")
+        })
+      ).optional().describe("Role bindings (required for personal keys)"),
       projectIds: z2.array(z2.string()).optional().describe("Project IDs for service keys (creates ADMIN bindings per project)")
     },
     withToolLogging("platform_create_api_key", async (params) => {
       requireApiKey();
-      const { handleCreateApiKey } = await import("./create-api-key-YUS36KBU.js");
+      const { handleCreateApiKey } = await import("./create-api-key-NNYKARMG.js");
       return {
         content: [{ type: "text", text: await handleCreateApiKey(params) }]
       };
@@ -2314,7 +2639,7 @@ The token is returned once and cannot be retrieved again.`,
     },
     withToolLogging("platform_revoke_api_key", async (params) => {
       requireApiKey();
-      const { handleRevokeApiKey } = await import("./revoke-api-key-FTRTZMOF.js");
+      const { handleRevokeApiKey } = await import("./revoke-api-key-SFMEFWJC.js");
       return {
         content: [{ type: "text", text: await handleRevokeApiKey(params) }]
       };
@@ -2325,4 +2650,4 @@ The token is returned once and cannot be retrieved again.`,
 export {
   createMcpServer
 };
-//# sourceMappingURL=chunk-4QC7SA2L.js.map
+//# sourceMappingURL=chunk-J7PQKBLD.js.map