@langwatch/mcp-server 0.8.0 → 0.10.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.10.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",
@@ -31187,8 +31187,7 @@ var init_package = __esm({
       },
       pnpm: {
         overrides: {
-          protobufjs: ">=7.5.6 <8.0.0 || >=8.0.2",
-          "fast-uri@<3.1.2": "3.1.2"
+          liquidjs: ">=10.26.0"
         }
       }
     };
@@ -31227,6 +31226,644 @@ 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/experiment-run-status.ts
+var INTERRUPTED_THRESHOLD_MS, deriveRunStatus, isTerminalStatus;
+var init_experiment_run_status = __esm({
+  "src/tools/experiment-run-status.ts"() {
+    "use strict";
+    INTERRUPTED_THRESHOLD_MS = 5 * 60 * 1e3;
+    deriveRunStatus = (timestamps, now = Date.now()) => {
+      if (timestamps.stoppedAt != null) return "stopped";
+      if (timestamps.finishedAt != null) return "completed";
+      if (timestamps.updatedAt != null && now - timestamps.updatedAt > INTERRUPTED_THRESHOLD_MS) {
+        return "interrupted";
+      }
+      return "running";
+    };
+    isTerminalStatus = (status) => status === "completed" || status === "stopped";
+  }
+});
+
+// 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 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 error48;
+  }
+  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 partial2 = !isTerminalStatus(runStatus2);
+  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(`**Status**: ${runStatus2}`);
+  if (typeof results.total === "number" && results.total > 0) {
+    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 (partial2) {
+    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} |`
+      );
+    }
+    lines.push("");
+  }
+  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._");
+    }
+    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();
+    init_experiment_run_status();
+    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 statusFromResults(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 (error48) {
+    const code = error48 instanceof LangWatchApiError ? error48.status : void 0;
+    const message = error48 instanceof Error ? error48.message : String(error48);
+    if (code === 404 || code === void 0 && /404|not found/i.test(message)) {
+      return null;
+    }
+    throw error48;
+  }
+  const status = deriveRunStatus(results.timestamps);
+  const total = results.total ?? results.dataset?.length ?? 0;
+  const progress = results.progress ?? results.dataset?.length ?? 0;
+  const lines = [];
+  lines.push(`# Evaluation Run ${params.runId}
+`);
+  lines.push(`**Status**: ${status}`);
+  lines.push(`**Progress**: ${progress}/${total} cells`);
+  if (results.timestamps.createdAt) {
+    lines.push(
+      `**Started**: ${new Date(results.timestamps.createdAt).toISOString()}`
+    );
+  }
+  if (results.timestamps.finishedAt) {
+    lines.push(
+      `**Finished**: ${new Date(results.timestamps.finishedAt).toISOString()}`
+    );
+  }
+  if (results.timestamps.stoppedAt) {
+    lines.push(
+      `**Stopped**: ${new Date(results.timestamps.stoppedAt).toISOString()}`
+    );
+  }
+  lines.push("");
+  lines.push(
+    "> Use `platform_experiment_results` to fetch the per-row scores (partial results are available even while running)."
+  );
+  return lines.join("\n");
+}
+async function handleExperimentStatus(params) {
+  let status;
+  try {
+    status = await makeRequest(
+      "GET",
+      `/api/experiments/runs/${encodeURIComponent(params.runId)}`
+    );
+  } catch (error48) {
+    const code = error48 instanceof LangWatchApiError ? error48.status : void 0;
+    const message = error48 instanceof Error ? error48.message : String(error48);
+    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 error48;
+  }
+  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();
+    init_experiment_run_status();
+  }
+});
+
 // src/tools/discover-scenario-schema.ts
 var discover_scenario_schema_exports = {};
 __export(discover_scenario_schema_exports, {
@@ -33185,122 +33822,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();
@@ -35356,96 +35877,30 @@ 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");
+  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_run_evaluation = __esm({
-  "src/tools/run-evaluation.ts"() {
+var init_langwatch_api_secrets = __esm({
+  "src/langwatch-api-secrets.ts"() {
     "use strict";
     init_langwatch_api();
   }
@@ -35826,6 +36281,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 +37841,89 @@ ${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 (running, completed, stopped, or interrupted) plus its progress. Works for both platform-run and SDK-logged experiments; pass experimentSlug for SDK runs or runs older than 24h.",
+    {
+      runId: external_exports.string().describe("The run ID returned from platform_run_experiment"),
+      experimentSlug: external_exports.string().optional().describe(
+        "Experiment slug \u2014 required for SDK-logged runs and runs older than 24h (the Redis run-state they would otherwise be read from is absent/expired). Use platform_experiment_list_runs to find the slug."
+      )
+    },
+    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 an experiment run so you can debug evaluator scores and missed rows. Serves partial results for runs that are still running or were interrupted (it does not require a completed run), with the run status noted in the output. 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 +38082,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 +38227,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"'
     );
@@ -62565,7 +63517,8 @@ async function startHttpServer({
   });
   const sseSessions = {};
   app.get("/sse", async (req, res) => {
-    const apiKey = extractBearerToken(req) || req.query["apiKey"] || null;
+    const apiKey = extractBearerToken(req) || // lgtm[js/sensitive-get-query]
+    req.query["apiKey"] || null;
     if (!apiKey) {
       res.status(401).json({
         error: "Authorization: Bearer <LANGWATCH_API_KEY> header or ?apiKey= query parameter required"