@langwatch/mcp-server 0.8.0 → 0.9.0

package/dist/index.js

@@ -31109,7 +31109,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@langwatch/mcp-server",
-      version: "0.8.0",
+      version: "0.9.0",
       description: "An MCP server for Langwatch.",
       type: "module",
       main: "./dist/index.js",
@@ -31160,7 +31160,7 @@ var init_package = __esm({
         "@types/node": "^25.6.0",
         "@types/yargs": "^17.0.33",
         "@typescript/native-preview": "7.0.0-dev.20250911.1",
-        ai: "^6.0.0",
+        ai: "^6.0.161",
         dotenv: "^17.2.2",
         esbuild: "^0.25.0",
         eslint: "^10.2.1",
@@ -31188,6 +31188,7 @@ var init_package = __esm({
       pnpm: {
         overrides: {
           protobufjs: ">=7.5.6 <8.0.0 || >=8.0.2",
+          "langsmith@<0.6.0": "0.6.0",
           "fast-uri@<3.1.2": "3.1.2"
         }
       }
@@ -31227,6 +31228,533 @@ var init_create_dataset = __esm({
   }
 });
 
+// src/langwatch-api.ts
+async function makeRequest(method, path, body) {
+  const config2 = getConfig();
+  const url2 = config2.endpoint + path;
+  const headers = {
+    "X-Auth-Token": requireApiKey()
+  };
+  if (config2.projectId) {
+    headers["X-Project-Id"] = config2.projectId;
+  }
+  if (body !== void 0) {
+    headers["Content-Type"] = "application/json";
+  }
+  const response = await fetch(url2, {
+    method,
+    headers,
+    ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+  });
+  if (!response.ok) {
+    const responseBody = await response.text();
+    throw new LangWatchApiError(
+      `LangWatch API error ${response.status}: ${responseBody}`,
+      response.status,
+      responseBody
+    );
+  }
+  if (response.status === 204 || response.headers?.get("content-length") === "0") {
+    return null;
+  }
+  return response.json();
+}
+async function searchTraces(params) {
+  const { format: format3 = "digest", ...rest } = params;
+  return makeRequest("POST", "/api/traces/search", {
+    ...rest,
+    format: format3
+  });
+}
+async function getTraceById(traceId, format3 = "digest") {
+  return makeRequest(
+    "GET",
+    `/api/traces/${encodeURIComponent(traceId)}?format=${format3}`
+  );
+}
+async function getAnalyticsTimeseries(params) {
+  return makeRequest(
+    "POST",
+    "/api/analytics/timeseries",
+    params
+  );
+}
+async function listPrompts() {
+  return makeRequest("GET", "/api/prompts");
+}
+async function getPrompt(idOrHandle, options) {
+  const params = new URLSearchParams();
+  if (options?.version != null) params.set("version", String(options.version));
+  if (options?.tag) params.set("tag", options.tag);
+  const query = params.toString() ? `?${params}` : "";
+  return makeRequest(
+    "GET",
+    `/api/prompts/${encodeURIComponent(idOrHandle)}${query}`
+  );
+}
+async function createPrompt(data) {
+  return makeRequest(
+    "POST",
+    "/api/prompts",
+    data
+  );
+}
+async function updatePrompt(idOrHandle, data) {
+  return makeRequest(
+    "PUT",
+    `/api/prompts/${encodeURIComponent(idOrHandle)}`,
+    data
+  );
+}
+async function assignPromptTag({
+  idOrHandle,
+  tag,
+  versionId
+}) {
+  return makeRequest(
+    "PUT",
+    `/api/prompts/${encodeURIComponent(idOrHandle)}/tags/${encodeURIComponent(tag)}`,
+    { versionId }
+  );
+}
+async function listPromptTags() {
+  return makeRequest("GET", "/api/prompts/tags");
+}
+async function createPromptTag(name) {
+  return makeRequest("POST", "/api/prompts/tags", { name });
+}
+async function renamePromptTag({
+  tag,
+  name
+}) {
+  return makeRequest(
+    "PUT",
+    `/api/prompts/tags/${encodeURIComponent(tag)}`,
+    { name }
+  );
+}
+async function deletePromptTag(tag) {
+  return makeRequest(
+    "DELETE",
+    `/api/prompts/tags/${encodeURIComponent(tag)}`
+  );
+}
+var LangWatchApiError;
+var init_langwatch_api = __esm({
+  "src/langwatch-api.ts"() {
+    "use strict";
+    init_config();
+    LangWatchApiError = class extends Error {
+      constructor(message, status, responseBody) {
+        super(message);
+        this.status = status;
+        this.responseBody = responseBody;
+        this.name = "LangWatchApiError";
+      }
+    };
+  }
+});
+
+// src/tools/get-experiment-results.ts
+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;
+  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 (error48) {
+    const message = error48 instanceof Error ? error48.message : String(error48);
+    const status = error48 instanceof LangWatchApiError ? error48.status : error48 && typeof error48 === "object" && "status" in error48 && typeof error48.status === "number" ? error48.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 may still be in progress, or the id may be incorrect.`,
+        "",
+        "> Try `platform_experiment_status` first to confirm the run id and that it is completed."
+      ].join("\n");
+    }
+    throw error48;
+  }
+  if (!results || results.timestamps.finishedAt == null && results.timestamps.stoppedAt == null) {
+    return [
+      `# Evaluation Results: ${params.runId}`,
+      "",
+      "**Status**: results are not yet available",
+      "",
+      `Results for run \`${params.runId}\` are not ready yet.`,
+      "",
+      "> Try `platform_experiment_status` first to confirm the run id and that it is completed."
+    ].join("\n");
+  }
+  const evaluationsByRow = /* @__PURE__ */ new Map();
+  for (const evaluation of results.evaluations) {
+    if (evaluatorFilter && evaluation.evaluator !== evaluatorFilter) continue;
+    const key = rowKey(evaluation.index, evaluation.targetId);
+    const list = evaluationsByRow.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 })
+    );
+  }
+  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) {
+    for (const e of r.evaluations) {
+      const stats = evaluatorAverages.get(e.evaluator) ?? {
+        sum: 0,
+        count: 0,
+        passed: 0,
+        failed: 0,
+        errored: 0
+      };
+      if (typeof e.score === "number") {
+        stats.sum += e.score;
+        stats.count += 1;
+      }
+      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);
+    }
+  }
+  const lines = [];
+  lines.push(`# Evaluation Results: ${results.runId}`);
+  lines.push("");
+  lines.push(`**Experiment**: ${results.experimentId}`);
+  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}`);
+  }
+  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} |`
+      );
+    }
+    lines.push("");
+  }
+  if (rows.length === 0) {
+    lines.push("_No rows matched the filter._");
+    return lines.join("\n");
+  }
+  lines.push(
+    `## Rows (${rows.length}${truncated ? ` of ${totalMatching}` : ""})`
+  );
+  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("");
+  }
+  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.`
+    );
+  }
+  return lines.join("\n");
+}
+var DEFAULT_ROW_CAP, rowKey, summarizeEntry, isFailedEvaluation, isFailedRow;
+var init_get_experiment_results = __esm({
+  "src/tools/get-experiment-results.ts"() {
+    "use strict";
+    init_langwatch_api();
+    DEFAULT_ROW_CAP = 50;
+    rowKey = (index, targetId) => `${index}:${targetId ?? ""}`;
+    summarizeEntry = (entry) => {
+      const candidates = ["input", "question", "query", "prompt", "user"];
+      for (const key of candidates) {
+        const value = entry[key];
+        if (typeof value === "string" && value.length > 0) {
+          return value.length > 80 ? `${value.slice(0, 77)}...` : value;
+        }
+      }
+      return "";
+    };
+    isFailedEvaluation = (e) => e.status === "error" || e.passed === false;
+    isFailedRow = ({
+      entry,
+      evaluations
+    }) => Boolean(entry.error) || evaluations.some(isFailedEvaluation);
+  }
+});
+
+// src/tools/list-experiment-runs.ts
+async function handleExperimentListRuns(params) {
+  const requested = typeof params.limit === "number" && params.limit > 0 ? params.limit : DEFAULT_LIMIT;
+  const effectiveLimit = Math.min(requested, MAX_LIMIT);
+  const search = new URLSearchParams();
+  search.set("experimentSlug", params.experimentSlug);
+  search.set("pageSize", String(effectiveLimit));
+  let result;
+  try {
+    result = await makeRequest(
+      "GET",
+      `/api/experiments/runs?${search.toString()}`
+    );
+  } catch (error48) {
+    const message = error48 instanceof Error ? error48.message : String(error48);
+    if (/404|not found/i.test(message)) {
+      return [
+        `# Evaluation Runs: ${params.experimentSlug}`,
+        "",
+        "**Status**: experiment not found",
+        "",
+        `No experiment with slug \`${params.experimentSlug}\` exists in this project.`,
+        "",
+        "> Run `platform_experiment_list` to discover available experiment slugs."
+      ].join("\n");
+    }
+    throw error48;
+  }
+  if (result.runs.length === 0) {
+    return [
+      `# Evaluation Runs: ${result.experimentSlug}`,
+      "",
+      "_This experiment has no runs yet._",
+      "",
+      `> Trigger a run with \`platform_run_experiment\` (slug: \`${result.experimentSlug}\`) to populate this list.`
+    ].join("\n");
+  }
+  const lines = [];
+  lines.push(`# Evaluation Runs: ${result.experimentSlug}`);
+  lines.push("");
+  lines.push(
+    `Showing ${result.runs.length} of ${result.pagination.totalHits} run${result.pagination.totalHits === 1 ? "" : "s"}.`
+  );
+  if (result.pagination.hasMore) {
+    lines.push(
+      `> More runs exist beyond this limit. Re-run with a higher \`limit\` (max ${MAX_LIMIT}) if needed.`
+    );
+  }
+  lines.push("");
+  lines.push("| Run ID | Status | Started | Finished | Result |");
+  lines.push("|--------|--------|---------|----------|--------|");
+  for (const run of result.runs) {
+    lines.push(
+      `| \`${run.runId}\` | ${runStatus(run)} | ${formatEpoch(run.timestamps.createdAt)} | ${formatEpoch(run.timestamps.finishedAt ?? null)} | ${passRate(run.summary?.evaluations ?? {})} |`
+    );
+  }
+  lines.push("");
+  lines.push(
+    "> Use `platform_experiment_status <runId>` for live progress, or `platform_experiment_results <runId>` for per-row results."
+  );
+  return lines.join("\n");
+}
+var DEFAULT_LIMIT, MAX_LIMIT, formatEpoch, passRate, runStatus;
+var init_list_experiment_runs = __esm({
+  "src/tools/list-experiment-runs.ts"() {
+    "use strict";
+    init_langwatch_api();
+    DEFAULT_LIMIT = 25;
+    MAX_LIMIT = 100;
+    formatEpoch = (epoch) => {
+      if (!epoch || !Number.isFinite(epoch)) return "\u2014";
+      return new Date(epoch).toISOString().replace("T", " ").slice(0, 19) + " UTC";
+    };
+    passRate = (evaluations) => {
+      const entries = Object.values(evaluations ?? {});
+      if (entries.length === 0) return "\u2014";
+      const passed = entries.filter((e) => typeof e.averagePassed === "number");
+      if (passed.length === 0) {
+        const scored = entries.filter((e) => typeof e.averageScore === "number");
+        if (scored.length === 0) return "\u2014";
+        const avg2 = scored.reduce((sum, e) => sum + (e.averageScore ?? 0), 0) / scored.length;
+        return `${avg2.toFixed(2)} avg`;
+      }
+      const avg = passed.reduce((sum, e) => sum + (e.averagePassed ?? 0), 0) / passed.length;
+      return `${(avg * 100).toFixed(0)}% pass`;
+    };
+    runStatus = (run) => {
+      if (run.timestamps.stoppedAt) return "stopped";
+      if (run.timestamps.finishedAt) return "completed";
+      return "running";
+    };
+  }
+});
+
+// src/tools/list-experiments.ts
+async function handleExperimentList(params) {
+  const requested = typeof params.limit === "number" && params.limit > 0 ? params.limit : DEFAULT_LIMIT2;
+  const effectiveLimit = Math.min(requested, MAX_LIMIT2);
+  const search = new URLSearchParams();
+  search.set("pageSize", String(effectiveLimit));
+  const result = await makeRequest(
+    "GET",
+    `/api/experiments?${search.toString()}`
+  );
+  if (result.experiments.length === 0) {
+    return [
+      "# Experiments",
+      "",
+      "_No experiments found in this project._",
+      "",
+      "> Create an experiment in the LangWatch dashboard, then re-run this tool to discover its slug."
+    ].join("\n");
+  }
+  const lines = [];
+  lines.push("# Experiments");
+  lines.push("");
+  lines.push(
+    `Showing ${result.experiments.length} of ${result.pagination.totalHits} experiment${result.pagination.totalHits === 1 ? "" : "s"}.`
+  );
+  if (result.pagination.hasMore) {
+    lines.push(
+      `> More experiments exist beyond this limit. Re-run with a higher \`limit\` (max ${MAX_LIMIT2}) if needed.`
+    );
+  }
+  lines.push("");
+  lines.push("| Slug | Name | Runs | Last Run |");
+  lines.push("|------|------|------|----------|");
+  for (const exp of result.experiments) {
+    const name = escapeMarkdownTableCell(exp.name ?? exp.slug);
+    lines.push(
+      `| ${formatInlineCode(exp.slug)} | ${name} | ${exp.runsCount} | ${formatTimestamp(exp.lastRunAt)} |`
+    );
+  }
+  lines.push("");
+  lines.push(
+    "> Use `platform_experiment_list_runs` with one of these slugs to see its runs."
+  );
+  return lines.join("\n");
+}
+var DEFAULT_LIMIT2, MAX_LIMIT2, formatTimestamp, escapeMarkdownTableCell, formatInlineCode;
+var init_list_experiments = __esm({
+  "src/tools/list-experiments.ts"() {
+    "use strict";
+    init_langwatch_api();
+    DEFAULT_LIMIT2 = 25;
+    MAX_LIMIT2 = 100;
+    formatTimestamp = (iso) => {
+      if (!iso) return "\u2014";
+      const d = new Date(iso);
+      if (Number.isNaN(d.getTime())) return iso;
+      return d.toISOString().replace("T", " ").slice(0, 19) + " UTC";
+    };
+    escapeMarkdownTableCell = (value) => value.replace(/[\\|]/g, (c) => `\\${c}`).replace(/\n/g, " ");
+    formatInlineCode = (value) => `\`${value.replace(/[\\`|]/g, (c) => `\\${c}`).replace(/\n/g, " ")}\``;
+  }
+});
+
+// src/tools/run-experiment.ts
+async function handleRunExperiment(params) {
+  const result = await makeRequest(
+    "POST",
+    `/api/experiments/${encodeURIComponent(params.slug)}/run`
+  );
+  const lines = [];
+  lines.push(`Evaluation started!
+`);
+  lines.push(`**Run ID**: ${result.runId}`);
+  lines.push(`**Status**: ${result.status}`);
+  lines.push(`**Total cells**: ${result.total}`);
+  if (result.runUrl) lines.push(`**View at**: ${result.runUrl}`);
+  lines.push("");
+  lines.push(
+    `> Use \`platform_experiment_status\` with run ID "${result.runId}" to check progress.`
+  );
+  return lines.join("\n");
+}
+async function handleExperimentStatus(params) {
+  const status = await makeRequest(
+    "GET",
+    `/api/experiments/runs/${encodeURIComponent(params.runId)}`
+  );
+  const lines = [];
+  lines.push(`# Evaluation Run ${status.runId}
+`);
+  lines.push(`**Status**: ${status.status}`);
+  lines.push(`**Progress**: ${status.progress}/${status.total} cells`);
+  if (status.startedAt) {
+    lines.push(`**Started**: ${new Date(status.startedAt).toISOString()}`);
+  }
+  if (status.finishedAt) {
+    lines.push(`**Finished**: ${new Date(status.finishedAt).toISOString()}`);
+  }
+  if (status.summary) {
+    lines.push("\n## Summary\n");
+    if (status.summary.completedCells !== void 0) {
+      lines.push(`**Completed**: ${status.summary.completedCells}`);
+    }
+    if (status.summary.failedCells) {
+      lines.push(`**Failed**: ${status.summary.failedCells}`);
+    }
+    if (status.summary.duration) {
+      lines.push(
+        `**Duration**: ${(status.summary.duration / 1e3).toFixed(1)}s`
+      );
+    }
+    if (status.summary.runUrl) {
+      lines.push(`**View results**: ${status.summary.runUrl}`);
+    }
+  }
+  return lines.join("\n");
+}
+var init_run_experiment = __esm({
+  "src/tools/run-experiment.ts"() {
+    "use strict";
+    init_langwatch_api();
+  }
+});
+
 // src/tools/discover-scenario-schema.ts
 var discover_scenario_schema_exports = {};
 __export(discover_scenario_schema_exports, {
@@ -33185,122 +33713,6 @@ var init_discover_schema = __esm({
   }
 });
 
-// src/langwatch-api.ts
-async function makeRequest(method, path, body) {
-  const config2 = getConfig();
-  const url2 = config2.endpoint + path;
-  const headers = {
-    "X-Auth-Token": requireApiKey()
-  };
-  if (config2.projectId) {
-    headers["X-Project-Id"] = config2.projectId;
-  }
-  if (body !== void 0) {
-    headers["Content-Type"] = "application/json";
-  }
-  const response = await fetch(url2, {
-    method,
-    headers,
-    ...body !== void 0 ? { body: JSON.stringify(body) } : {}
-  });
-  if (!response.ok) {
-    const responseBody = await response.text();
-    throw new Error(
-      `LangWatch API error ${response.status}: ${responseBody}`
-    );
-  }
-  if (response.status === 204 || response.headers?.get("content-length") === "0") {
-    return null;
-  }
-  return response.json();
-}
-async function searchTraces(params) {
-  const { format: format3 = "digest", ...rest } = params;
-  return makeRequest("POST", "/api/traces/search", {
-    ...rest,
-    format: format3
-  });
-}
-async function getTraceById(traceId, format3 = "digest") {
-  return makeRequest(
-    "GET",
-    `/api/traces/${encodeURIComponent(traceId)}?format=${format3}`
-  );
-}
-async function getAnalyticsTimeseries(params) {
-  return makeRequest(
-    "POST",
-    "/api/analytics/timeseries",
-    params
-  );
-}
-async function listPrompts() {
-  return makeRequest("GET", "/api/prompts");
-}
-async function getPrompt(idOrHandle, options) {
-  const params = new URLSearchParams();
-  if (options?.version != null) params.set("version", String(options.version));
-  if (options?.tag) params.set("tag", options.tag);
-  const query = params.toString() ? `?${params}` : "";
-  return makeRequest(
-    "GET",
-    `/api/prompts/${encodeURIComponent(idOrHandle)}${query}`
-  );
-}
-async function createPrompt(data) {
-  return makeRequest(
-    "POST",
-    "/api/prompts",
-    data
-  );
-}
-async function updatePrompt(idOrHandle, data) {
-  return makeRequest(
-    "PUT",
-    `/api/prompts/${encodeURIComponent(idOrHandle)}`,
-    data
-  );
-}
-async function assignPromptTag({
-  idOrHandle,
-  tag,
-  versionId
-}) {
-  return makeRequest(
-    "PUT",
-    `/api/prompts/${encodeURIComponent(idOrHandle)}/tags/${encodeURIComponent(tag)}`,
-    { versionId }
-  );
-}
-async function listPromptTags() {
-  return makeRequest("GET", "/api/prompts/tags");
-}
-async function createPromptTag(name) {
-  return makeRequest("POST", "/api/prompts/tags", { name });
-}
-async function renamePromptTag({
-  tag,
-  name
-}) {
-  return makeRequest(
-    "PUT",
-    `/api/prompts/tags/${encodeURIComponent(tag)}`,
-    { name }
-  );
-}
-async function deletePromptTag(tag) {
-  return makeRequest(
-    "DELETE",
-    `/api/prompts/tags/${encodeURIComponent(tag)}`
-  );
-}
-var init_langwatch_api = __esm({
-  "src/langwatch-api.ts"() {
-    "use strict";
-    init_config();
-  }
-});
-
 // src/utils/date-parsing.ts
 function parseRelativeDate(input) {
   if (input === "now") return Date.now();
@@ -35355,97 +35767,31 @@ __export(langwatch_api_secrets_exports, {
 async function listSecrets() {
   return makeRequest("GET", "/api/secrets");
 }
-async function getSecret(id) {
-  return makeRequest(
-    "GET",
-    `/api/secrets/${encodeURIComponent(id)}`
-  );
-}
-async function createSecret(data) {
-  return makeRequest("POST", "/api/secrets", data);
-}
-async function updateSecret(params) {
-  const { id, value } = params;
-  return makeRequest(
-    "PUT",
-    `/api/secrets/${encodeURIComponent(id)}`,
-    { value }
-  );
-}
-async function deleteSecret(id) {
-  return makeRequest(
-    "DELETE",
-    `/api/secrets/${encodeURIComponent(id)}`
-  );
-}
-var init_langwatch_api_secrets = __esm({
-  "src/langwatch-api-secrets.ts"() {
-    "use strict";
-    init_langwatch_api();
-  }
-});
-
-// src/tools/run-evaluation.ts
-var run_evaluation_exports = {};
-__export(run_evaluation_exports, {
-  handleEvaluationStatus: () => handleEvaluationStatus,
-  handleRunEvaluation: () => handleRunEvaluation
-});
-async function handleRunEvaluation(params) {
-  const result = await makeRequest(
-    "POST",
-    `/api/evaluations/v3/${encodeURIComponent(params.slug)}/run`
-  );
-  const lines = [];
-  lines.push(`Evaluation started!
-`);
-  lines.push(`**Run ID**: ${result.runId}`);
-  lines.push(`**Status**: ${result.status}`);
-  lines.push(`**Total cells**: ${result.total}`);
-  if (result.runUrl) lines.push(`**View at**: ${result.runUrl}`);
-  lines.push("");
-  lines.push(
-    `> Use \`platform_evaluation_status\` with run ID "${result.runId}" to check progress.`
-  );
-  return lines.join("\n");
-}
-async function handleEvaluationStatus(params) {
-  const status = await makeRequest(
-    "GET",
-    `/api/evaluations/v3/runs/${encodeURIComponent(params.runId)}`
-  );
-  const lines = [];
-  lines.push(`# Evaluation Run ${status.runId}
-`);
-  lines.push(`**Status**: ${status.status}`);
-  lines.push(`**Progress**: ${status.progress}/${status.total} cells`);
-  if (status.startedAt) {
-    lines.push(`**Started**: ${new Date(status.startedAt).toISOString()}`);
-  }
-  if (status.finishedAt) {
-    lines.push(`**Finished**: ${new Date(status.finishedAt).toISOString()}`);
-  }
-  if (status.summary) {
-    lines.push("\n## Summary\n");
-    if (status.summary.completedCells !== void 0) {
-      lines.push(`**Completed**: ${status.summary.completedCells}`);
-    }
-    if (status.summary.failedCells) {
-      lines.push(`**Failed**: ${status.summary.failedCells}`);
-    }
-    if (status.summary.duration) {
-      lines.push(
-        `**Duration**: ${(status.summary.duration / 1e3).toFixed(1)}s`
-      );
-    }
-    if (status.summary.runUrl) {
-      lines.push(`**View results**: ${status.summary.runUrl}`);
-    }
-  }
-  return lines.join("\n");
+async function getSecret(id) {
+  return makeRequest(
+    "GET",
+    `/api/secrets/${encodeURIComponent(id)}`
+  );
+}
+async function createSecret(data) {
+  return makeRequest("POST", "/api/secrets", data);
+}
+async function updateSecret(params) {
+  const { id, value } = params;
+  return makeRequest(
+    "PUT",
+    `/api/secrets/${encodeURIComponent(id)}`,
+    { value }
+  );
 }
-var init_run_evaluation = __esm({
-  "src/tools/run-evaluation.ts"() {
+async function deleteSecret(id) {
+  return makeRequest(
+    "DELETE",
+    `/api/secrets/${encodeURIComponent(id)}`
+  );
+}
+var init_langwatch_api_secrets = __esm({
+  "src/langwatch-api-secrets.ts"() {
     "use strict";
     init_langwatch_api();
   }
@@ -35826,6 +36172,305 @@ var init_delete_dataset_records = __esm({
   }
 });
 
+// src/langwatch-api-projects.ts
+async function listProjects(params) {
+  const query = new URLSearchParams();
+  if (params?.page) query.set("page", String(params.page));
+  if (params?.limit) query.set("limit", String(params.limit));
+  const qs = query.toString() ? `?${query}` : "";
+  return makeRequest("GET", `/api/projects${qs}`);
+}
+async function getProject(id) {
+  return makeRequest(
+    "GET",
+    `/api/projects/${encodeURIComponent(id)}`
+  );
+}
+async function createProject(data) {
+  return makeRequest("POST", "/api/projects", data);
+}
+async function updateProject(params) {
+  const { id, ...data } = params;
+  return makeRequest(
+    "PATCH",
+    `/api/projects/${encodeURIComponent(id)}`,
+    data
+  );
+}
+async function archiveProject(id) {
+  return makeRequest(
+    "DELETE",
+    `/api/projects/${encodeURIComponent(id)}`
+  );
+}
+var init_langwatch_api_projects = __esm({
+  "src/langwatch-api-projects.ts"() {
+    "use strict";
+    init_langwatch_api();
+  }
+});
+
+// src/tools/list-projects.ts
+var list_projects_exports = {};
+__export(list_projects_exports, {
+  handleListProjects: () => handleListProjects
+});
+async function handleListProjects(params) {
+  const result = await listProjects({
+    page: params?.page,
+    limit: params?.limit ?? 100
+  });
+  const projects = result.data;
+  if (!Array.isArray(projects) || projects.length === 0) {
+    return "No projects found in this organization.\n\n> Tip: Use `platform_create_project` to create your first project.";
+  }
+  const lines = [];
+  lines.push(`# Projects (${result.pagination.total} total)
+`);
+  for (const p of projects) {
+    lines.push(`## ${p.name}`);
+    lines.push(`**ID**: ${p.id}`);
+    lines.push(`**Slug**: ${p.slug}`);
+    lines.push(`**Language**: ${p.language}`);
+    lines.push(`**Framework**: ${p.framework}`);
+    lines.push(`**Updated**: ${p.updatedAt}`);
+    lines.push("");
+  }
+  if (result.pagination.totalPages > 1) {
+    lines.push(
+      `> Showing page ${result.pagination.page} of ${result.pagination.totalPages}. Use \`page\` parameter to navigate.`
+    );
+  }
+  lines.push(
+    "> Use `platform_get_project` with the ID to see full project details."
+  );
+  return lines.join("\n");
+}
+var init_list_projects = __esm({
+  "src/tools/list-projects.ts"() {
+    "use strict";
+    init_langwatch_api_projects();
+  }
+});
+
+// src/tools/get-project.ts
+var get_project_exports = {};
+__export(get_project_exports, {
+  handleGetProject: () => handleGetProject
+});
+async function handleGetProject(params) {
+  const project = await getProject(params.id);
+  const lines = [];
+  lines.push(`# ${project.name}
+`);
+  lines.push(`**ID**: ${project.id}`);
+  lines.push(`**Slug**: ${project.slug}`);
+  lines.push(`**Language**: ${project.language}`);
+  lines.push(`**Framework**: ${project.framework}`);
+  lines.push(`**Team ID**: ${project.teamId}`);
+  lines.push(`**PII Redaction**: ${project.piiRedactionLevel}`);
+  lines.push(`**Created**: ${project.createdAt}`);
+  lines.push(`**Updated**: ${project.updatedAt}`);
+  return lines.join("\n");
+}
+var init_get_project = __esm({
+  "src/tools/get-project.ts"() {
+    "use strict";
+    init_langwatch_api_projects();
+  }
+});
+
+// src/tools/create-project.ts
+var create_project_exports = {};
+__export(create_project_exports, {
+  handleCreateProject: () => handleCreateProject
+});
+async function handleCreateProject(params) {
+  if (!params.teamId && !params.newTeamName) {
+    return "Error: You must provide either `teamId` (to add to an existing team) or `newTeamName` (to create a new team for this project).";
+  }
+  const result = await createProject({
+    name: params.name,
+    language: params.language,
+    framework: params.framework,
+    teamId: params.teamId,
+    newTeamName: params.newTeamName
+  });
+  if (!result.serviceApiKey) {
+    throw new Error(
+      "API did not return a service API key. The project was created but the key is missing \u2014 check the LangWatch UI."
+    );
+  }
+  const lines = [];
+  lines.push(`Project created successfully!
+`);
+  lines.push(`**Name**: ${result.name}`);
+  lines.push(`**ID**: ${result.id}`);
+  lines.push(`**Slug**: ${result.slug}`);
+  lines.push(`**Language**: ${result.language}`);
+  lines.push(`**Framework**: ${result.framework}`);
+  lines.push("");
+  lines.push(`**Service API Key**: \`${result.serviceApiKey}\``);
+  lines.push(`**Service API Key ID**: ${result.serviceApiKeyId}`);
+  lines.push("");
+  lines.push(
+    "> \u26A0\uFE0F Save the service API key now \u2014 it will not be shown again. Use it as `LANGWATCH_API_KEY` to authenticate project-scoped operations."
+  );
+  return lines.join("\n");
+}
+var init_create_project = __esm({
+  "src/tools/create-project.ts"() {
+    "use strict";
+    init_langwatch_api_projects();
+  }
+});
+
+// src/tools/update-project.ts
+var update_project_exports = {};
+__export(update_project_exports, {
+  handleUpdateProject: () => handleUpdateProject
+});
+async function handleUpdateProject(params) {
+  const project = await updateProject(params);
+  const lines = [];
+  lines.push(`Project updated successfully!
+`);
+  lines.push(`**Name**: ${project.name}`);
+  lines.push(`**ID**: ${project.id}`);
+  lines.push(`**Slug**: ${project.slug}`);
+  lines.push(`**Language**: ${project.language}`);
+  lines.push(`**Framework**: ${project.framework}`);
+  lines.push(`**PII Redaction**: ${project.piiRedactionLevel}`);
+  return lines.join("\n");
+}
+var init_update_project = __esm({
+  "src/tools/update-project.ts"() {
+    "use strict";
+    init_langwatch_api_projects();
+  }
+});
+
+// src/tools/archive-project.ts
+var archive_project_exports = {};
+__export(archive_project_exports, {
+  handleArchiveProject: () => handleArchiveProject
+});
+async function handleArchiveProject(params) {
+  const result = await archiveProject(params.id);
+  return `Project archived successfully.
+
+**Name**: ${result.name}
+**ID**: ${result.id}
+**Archived At**: ${result.archivedAt}`;
+}
+var init_archive_project = __esm({
+  "src/tools/archive-project.ts"() {
+    "use strict";
+    init_langwatch_api_projects();
+  }
+});
+
+// src/langwatch-api-api-keys.ts
+async function listApiKeys() {
+  return makeRequest("GET", "/api/api-keys");
+}
+async function createApiKey(data) {
+  return makeRequest("POST", "/api/api-keys", data);
+}
+async function revokeApiKey(id) {
+  return makeRequest(
+    "DELETE",
+    `/api/api-keys/${encodeURIComponent(id)}`
+  );
+}
+var init_langwatch_api_api_keys = __esm({
+  "src/langwatch-api-api-keys.ts"() {
+    "use strict";
+    init_langwatch_api();
+  }
+});
+
+// src/tools/list-api-keys.ts
+var list_api_keys_exports = {};
+__export(list_api_keys_exports, {
+  handleListApiKeys: () => handleListApiKeys
+});
+async function handleListApiKeys() {
+  const result = await listApiKeys();
+  const keys = result.data;
+  if (!Array.isArray(keys) || keys.length === 0) {
+    return "No API keys found.\n\n> Tip: Use `platform_create_api_key` to create a new key.";
+  }
+  const lines = [];
+  lines.push(`# API Keys (${keys.length} total)
+`);
+  for (const k of keys) {
+    const status = k.revokedAt ? "REVOKED" : k.expiresAt && new Date(k.expiresAt) < /* @__PURE__ */ new Date() ? "EXPIRED" : "ACTIVE";
+    lines.push(`## ${k.name}`);
+    lines.push(`**ID**: ${k.id}`);
+    lines.push(`**Status**: ${status}`);
+    if (k.description) lines.push(`**Description**: ${k.description}`);
+    if (k.expiresAt) lines.push(`**Expires**: ${k.expiresAt}`);
+    if (k.lastUsedAt) lines.push(`**Last Used**: ${k.lastUsedAt}`);
+    lines.push(`**Created**: ${k.createdAt}`);
+    if (k.roleBindings.length > 0) {
+      const bindings = k.roleBindings.map((rb) => `${rb.role} on ${rb.scopeType}:${rb.scopeId}`).join(", ");
+      lines.push(`**Bindings**: ${bindings}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+var init_list_api_keys = __esm({
+  "src/tools/list-api-keys.ts"() {
+    "use strict";
+    init_langwatch_api_api_keys();
+  }
+});
+
+// src/tools/create-api-key.ts
+var create_api_key_exports = {};
+__export(create_api_key_exports, {
+  handleCreateApiKey: () => handleCreateApiKey
+});
+async function handleCreateApiKey(params) {
+  const result = await createApiKey(params);
+  const lines = [];
+  lines.push(`API key created successfully!
+`);
+  lines.push(`**Name**: ${result.apiKey.name}`);
+  lines.push(`**ID**: ${result.apiKey.id}`);
+  lines.push(`**Token**: \`${result.token}\``);
+  lines.push(`**Created**: ${result.apiKey.createdAt}`);
+  lines.push("");
+  lines.push(
+    "> \u26A0\uFE0F Save this token now \u2014 it will not be shown again."
+  );
+  return lines.join("\n");
+}
+var init_create_api_key = __esm({
+  "src/tools/create-api-key.ts"() {
+    "use strict";
+    init_langwatch_api_api_keys();
+  }
+});
+
+// src/tools/revoke-api-key.ts
+var revoke_api_key_exports = {};
+__export(revoke_api_key_exports, {
+  handleRevokeApiKey: () => handleRevokeApiKey
+});
+async function handleRevokeApiKey(params) {
+  await revokeApiKey(params.id);
+  return `API key ${params.id} revoked successfully.`;
+}
+var init_revoke_api_key = __esm({
+  "src/tools/revoke-api-key.ts"() {
+    "use strict";
+    init_langwatch_api_api_keys();
+  }
+});
+
 // src/create-mcp-server.ts
 function createMcpServer() {
   const server = new McpServer({
@@ -37087,30 +37732,86 @@ ${lines.join("\n")}`
     })
   );
   server.tool(
-    "platform_run_evaluation",
-    "Start an evaluation run by slug. Returns a run ID for polling status.",
+    "platform_run_experiment",
+    "Start an experiment run by slug. Returns a run ID for polling status.",
+    {
+      slug: external_exports.string().describe("The experiment slug to run")
+    },
+    withToolLogging("platform_run_experiment", async (params) => {
+      requireApiKey();
+      return {
+        content: [{ type: "text", text: await handleRunExperiment(params) }]
+      };
+    })
+  );
+  server.tool(
+    "platform_experiment_status",
+    "Check the status of an experiment run. Returns progress and summary when completed.",
+    {
+      runId: external_exports.string().describe("The run ID returned from platform_run_experiment")
+    },
+    withToolLogging("platform_experiment_status", async (params) => {
+      requireApiKey();
+      return {
+        content: [{ type: "text", text: await handleExperimentStatus(params) }]
+      };
+    })
+  );
+  server.tool(
+    "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: external_exports.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();
+      return {
+        content: [{ type: "text", text: await handleExperimentList(params) }]
+      };
+    })
+  );
+  server.tool(
+    "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.",
     {
-      slug: external_exports.string().describe("The evaluation slug to run")
+      experimentSlug: external_exports.string().describe(
+        "Experiment slug from platform_experiment_list (e.g. 'checkout-flow')"
+      ),
+      limit: external_exports.number().int().positive().max(100).optional().describe(
+        "Maximum number of runs to include (default 25, hard-capped at 100)"
+      )
     },
-    withToolLogging("platform_run_evaluation", async (params) => {
+    withToolLogging("platform_experiment_list_runs", async (params) => {
       requireApiKey();
-      const { handleRunEvaluation: handleRunEvaluation2 } = await Promise.resolve().then(() => (init_run_evaluation(), run_evaluation_exports));
       return {
-        content: [{ type: "text", text: await handleRunEvaluation2(params) }]
+        content: [{ type: "text", text: await handleExperimentListRuns(params) }]
       };
     })
   );
   server.tool(
-    "platform_evaluation_status",
-    "Check the status of an evaluation run. Returns progress and summary when completed.",
+    "platform_experiment_results",
+    "Fetch per-row results for a completed experiment run so you can debug evaluator scores and missed rows. Returns a markdown report: per-evaluator averages plus row-by-row scores and failure details. Output is capped at 50 rows to protect the agent's context window \u2014 narrow with `filter: 'failed'` or `evaluator` to see what matters.",
     {
-      runId: external_exports.string().describe("The run ID returned from platform_run_evaluation")
+      runId: external_exports.string().describe("The run ID returned from platform_run_experiment"),
+      experimentSlug: external_exports.string().optional().describe(
+        "Experiment slug \u2014 required when fetching results for runs older than 24h (Redis state may have expired). Use platform_experiment_list_runs to find the slug."
+      ),
+      filter: external_exports.enum(["all", "failed"]).optional().describe(
+        "Filter rows: 'failed' shows only rows that errored or failed an evaluation; 'all' (default) shows everything"
+      ),
+      evaluator: external_exports.string().optional().describe("Show only this evaluator's results (matched on `evaluator` field)"),
+      limit: external_exports.number().int().positive().max(50).optional().describe(
+        "Maximum number of rows to include in the markdown output (default 50, hard-capped at 50)."
+      )
     },
-    withToolLogging("platform_evaluation_status", async (params) => {
+    withToolLogging("platform_experiment_results", async (params) => {
       requireApiKey();
-      const { handleEvaluationStatus: handleEvaluationStatus2 } = await Promise.resolve().then(() => (init_run_evaluation(), run_evaluation_exports));
       return {
-        content: [{ type: "text", text: await handleEvaluationStatus2(params) }]
+        content: [
+          { type: "text", text: await handleExperimentResults(params) }
+        ]
       };
     })
   );
@@ -37269,6 +37970,141 @@ ${lines.join("\n")}`
       };
     }
   );
+  server.tool(
+    "platform_list_projects",
+    "List all projects in your LangWatch organization. Requires an org-level API key.",
+    {
+      page: external_exports.number().int().positive().optional().describe("Page number (default: 1)"),
+      limit: external_exports.number().int().positive().max(1e3).optional().describe("Results per page (default: 100)")
+    },
+    withToolLogging("platform_list_projects", async (params) => {
+      requireApiKey();
+      const { handleListProjects: handleListProjects2 } = await Promise.resolve().then(() => (init_list_projects(), list_projects_exports));
+      return {
+        content: [{ type: "text", text: await handleListProjects2(params) }]
+      };
+    })
+  );
+  server.tool(
+    "platform_get_project",
+    "Get details of a specific project by its ID.",
+    {
+      id: external_exports.string().describe("The project ID")
+    },
+    withToolLogging("platform_get_project", async (params) => {
+      requireApiKey();
+      const { handleGetProject: handleGetProject2 } = await Promise.resolve().then(() => (init_get_project(), get_project_exports));
+      return {
+        content: [{ type: "text", text: await handleGetProject2(params) }]
+      };
+    })
+  );
+  server.tool(
+    "platform_create_project",
+    `Create a new project in your LangWatch organization. Returns a one-time service API key for the project.
+
+You must provide either teamId (to add the project to an existing team) or newTeamName (to create a new team for the project).`,
+    {
+      name: external_exports.string().describe("Project name"),
+      language: external_exports.string().describe('Programming language (e.g. "python", "typescript")'),
+      framework: external_exports.string().describe('Framework (e.g. "openai", "langchain", "custom")'),
+      teamId: external_exports.string().optional().describe("ID of an existing team to add the project to"),
+      newTeamName: external_exports.string().optional().describe("Name for a new team to create for this project")
+    },
+    withToolLogging("platform_create_project", async (params) => {
+      requireApiKey();
+      const { handleCreateProject: handleCreateProject2 } = await Promise.resolve().then(() => (init_create_project(), create_project_exports));
+      return {
+        content: [{ type: "text", text: await handleCreateProject2(params) }]
+      };
+    })
+  );
+  server.tool(
+    "platform_update_project",
+    "Update an existing project's name, language, framework, or PII redaction level.",
+    {
+      id: external_exports.string().describe("The project ID to update"),
+      name: external_exports.string().optional().describe("New project name"),
+      language: external_exports.string().optional().describe("New programming language"),
+      framework: external_exports.string().optional().describe("New framework"),
+      piiRedactionLevel: external_exports.enum(["STRICT", "ESSENTIAL", "DISABLED"]).optional().describe("PII redaction level")
+    },
+    withToolLogging("platform_update_project", async (params) => {
+      requireApiKey();
+      const { handleUpdateProject: handleUpdateProject2 } = await Promise.resolve().then(() => (init_update_project(), update_project_exports));
+      return {
+        content: [{ type: "text", text: await handleUpdateProject2(params) }]
+      };
+    })
+  );
+  server.tool(
+    "platform_archive_project",
+    "Archive (soft-delete) a project. The project can be restored later if needed.",
+    {
+      id: external_exports.string().describe("The project ID to archive")
+    },
+    withToolLogging("platform_archive_project", async (params) => {
+      requireApiKey();
+      const { handleArchiveProject: handleArchiveProject2 } = await Promise.resolve().then(() => (init_archive_project(), archive_project_exports));
+      return {
+        content: [{ type: "text", text: await handleArchiveProject2(params) }]
+      };
+    })
+  );
+  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: handleListApiKeys2 } = await Promise.resolve().then(() => (init_list_api_keys(), list_api_keys_exports));
+      return {
+        content: [{ type: "text", text: await handleListApiKeys2() }]
+      };
+    })
+  );
+  server.tool(
+    "platform_create_api_key",
+    `Create a new API key. Two types available:
+
+- **personal**: Tied to a user, requires explicit role bindings (e.g. ADMIN on PROJECT:proj_123).
+- **service**: Not tied to a user. Use projectIds for project-scoped service keys, or omit for org-wide access.
+
+The token is returned once and cannot be retrieved again.`,
+    {
+      keyType: external_exports.enum(["personal", "service"]).describe("Key type: 'personal' (user-tied) or 'service' (headless)"),
+      name: external_exports.string().describe("Key name (max 100 chars)"),
+      description: external_exports.string().optional().describe("Key description (max 500 chars)"),
+      expiresAt: external_exports.string().optional().describe("Expiration date (ISO string)"),
+      bindings: external_exports.array(external_exports.object({
+        role: external_exports.enum(["ADMIN", "MEMBER", "VIEWER"]).describe("Role"),
+        scopeType: external_exports.enum(["ORGANIZATION", "TEAM", "PROJECT"]).describe("Scope type"),
+        scopeId: external_exports.string().describe("Scope ID (org, team, or project ID)")
+      })).optional().describe("Role bindings (required for personal keys)"),
+      projectIds: external_exports.array(external_exports.string()).optional().describe("Project IDs for service keys (creates ADMIN bindings per project)")
+    },
+    withToolLogging("platform_create_api_key", async (params) => {
+      requireApiKey();
+      const { handleCreateApiKey: handleCreateApiKey2 } = await Promise.resolve().then(() => (init_create_api_key(), create_api_key_exports));
+      return {
+        content: [{ type: "text", text: await handleCreateApiKey2(params) }]
+      };
+    })
+  );
+  server.tool(
+    "platform_revoke_api_key",
+    "Revoke an API key. Once revoked, the key can no longer be used for authentication.",
+    {
+      id: external_exports.string().describe("The API key ID to revoke")
+    },
+    withToolLogging("platform_revoke_api_key", async (params) => {
+      requireApiKey();
+      const { handleRevokeApiKey: handleRevokeApiKey2 } = await Promise.resolve().then(() => (init_revoke_api_key(), revoke_api_key_exports));
+      return {
+        content: [{ type: "text", text: await handleRevokeApiKey2(params) }]
+      };
+    })
+  );
 }
 var modelSchema;
 var init_create_mcp_server = __esm({
@@ -37279,6 +38115,10 @@ var init_create_mcp_server = __esm({
     init_package();
     init_config();
     init_create_dataset();
+    init_get_experiment_results();
+    init_list_experiment_runs();
+    init_list_experiments();
+    init_run_experiment();
     modelSchema = external_exports.string().describe(
       'Model in "provider/model-name" format, e.g., "openai/gpt-4o", "anthropic/claude-sonnet-4-5-20250929"'
     );