@langwatch/mcp-server 0.7.0 → 0.9.0

package/dist/index.js

@@ -15919,7 +15919,8 @@ function initConfig(args) {
   const state = getGlobalState();
   state.globalConfig = {
     apiKey: args.apiKey || process.env.LANGWATCH_API_KEY,
-    endpoint: args.endpoint || process.env.LANGWATCH_ENDPOINT || "https://app.langwatch.ai"
+    endpoint: args.endpoint || process.env.LANGWATCH_ENDPOINT || "https://app.langwatch.ai",
+    projectId: process.env.LANGWATCH_PROJECT_ID
   };
 }
 function getConfig() {
@@ -25821,12 +25822,15 @@ var require_data = __commonJS({
   }
 });
 
-// node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/utils.js
+// node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/lib/utils.js
 var require_utils = __commonJS({
-  "node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/utils.js"(exports, module) {
+  "node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/lib/utils.js"(exports, module) {
     "use strict";
     var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
     var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+    var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
+    var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
+    var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
     function stringArrayToHexStripped(input) {
       let acc = "";
       let code = 0;
@@ -26019,27 +26023,77 @@ var require_utils = __commonJS({
       }
       return output.join("");
     }
-    function normalizeComponentEncoding(component, esc2) {
-      const func = esc2 !== true ? escape : unescape;
-      if (component.scheme !== void 0) {
-        component.scheme = func(component.scheme);
-      }
-      if (component.userinfo !== void 0) {
-        component.userinfo = func(component.userinfo);
-      }
-      if (component.host !== void 0) {
-        component.host = func(component.host);
+    var HOST_DELIMS = { "@": "%40", "/": "%2F", "?": "%3F", "#": "%23", ":": "%3A" };
+    var HOST_DELIM_RE = /[@/?#:]/g;
+    var HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
+    function reescapeHostDelimiters(host, isIP) {
+      const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
+      re.lastIndex = 0;
+      return host.replace(re, (ch) => HOST_DELIMS[ch]);
+    }
+    function normalizePercentEncoding(input, decodeUnreserved = false) {
+      if (input.indexOf("%") === -1) {
+        return input;
       }
-      if (component.path !== void 0) {
-        component.path = func(component.path);
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            const normalizedHex = hex3.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (decodeUnreserved && isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i += 2;
+            continue;
+          }
+        }
+        output += input[i];
       }
-      if (component.query !== void 0) {
-        component.query = func(component.query);
+      return output;
+    }
+    function normalizePathEncoding(input) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            const normalizedHex = hex3.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (decoded !== "." && isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i += 2;
+            continue;
+          }
+        }
+        if (isPathCharacter(input[i])) {
+          output += input[i];
+        } else {
+          output += escape(input[i]);
+        }
       }
-      if (component.fragment !== void 0) {
-        component.fragment = func(component.fragment);
+      return output;
+    }
+    function escapePreservingEscapes(input) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            output += "%" + hex3.toUpperCase();
+            i += 2;
+            continue;
+          }
+        }
+        output += escape(input[i]);
       }
-      return component;
+      return output;
     }
     function recomposeAuthority(component) {
       const uriTokens = [];
@@ -26054,7 +26108,7 @@ var require_utils = __commonJS({
           if (ipV6res.isIPV6 === true) {
             host = `[${ipV6res.escapedHost}]`;
           } else {
-            host = component.host;
+            host = reescapeHostDelimiters(host, false);
           }
         }
         uriTokens.push(host);
@@ -26068,7 +26122,10 @@ var require_utils = __commonJS({
     module.exports = {
       nonSimpleDomain,
       recomposeAuthority,
-      normalizeComponentEncoding,
+      reescapeHostDelimiters,
+      normalizePercentEncoding,
+      normalizePathEncoding,
+      escapePreservingEscapes,
       removeDotSegments,
       isIPv4,
       isUUID,
@@ -26078,9 +26135,9 @@ var require_utils = __commonJS({
   }
 });
 
-// node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/schemes.js
+// node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/lib/schemes.js
 var require_schemes = __commonJS({
-  "node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/schemes.js"(exports, module) {
+  "node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/lib/schemes.js"(exports, module) {
     "use strict";
     var { isUUID } = require_utils();
     var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
@@ -26288,16 +26345,16 @@ var require_schemes = __commonJS({
   }
 });
 
-// node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/index.js
+// node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/index.js
 var require_fast_uri = __commonJS({
-  "node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/index.js"(exports, module) {
+  "node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/index.js"(exports, module) {
     "use strict";
-    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
+    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
     function normalize2(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
-        serialize(parse3(uri, options), options);
+        normalizeString(uri, options);
       } else if (typeof uri === "object") {
         uri = /** @type {T} */
         parse3(serialize(uri, options), options);
@@ -26364,19 +26421,9 @@ var require_fast_uri = __commonJS({
       return target;
     }
     function equal(uriA, uriB, options) {
-      if (typeof uriA === "string") {
-        uriA = unescape(uriA);
-        uriA = serialize(normalizeComponentEncoding(parse3(uriA, options), true), { ...options, skipEscape: true });
-      } else if (typeof uriA === "object") {
-        uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true });
-      }
-      if (typeof uriB === "string") {
-        uriB = unescape(uriB);
-        uriB = serialize(normalizeComponentEncoding(parse3(uriB, options), true), { ...options, skipEscape: true });
-      } else if (typeof uriB === "object") {
-        uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true });
-      }
-      return uriA.toLowerCase() === uriB.toLowerCase();
+      const normalizedA = normalizeComparableURI(uriA, options);
+      const normalizedB = normalizeComparableURI(uriB, options);
+      return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
     }
     function serialize(cmpts, opts) {
       const component = {
@@ -26401,12 +26448,12 @@ var require_fast_uri = __commonJS({
       if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
       if (component.path !== void 0) {
         if (!options.skipEscape) {
-          component.path = escape(component.path);
+          component.path = escapePreservingEscapes(component.path);
           if (component.scheme !== void 0) {
             component.path = component.path.split("%3A").join(":");
           }
         } else {
-          component.path = unescape(component.path);
+          component.path = normalizePercentEncoding(component.path);
         }
       }
       if (options.reference !== "suffix" && component.scheme) {
@@ -26441,7 +26488,16 @@ var require_fast_uri = __commonJS({
       return uriTokens.join("");
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
-    function parse3(uri, opts) {
+    function getParseError(parsed, matches) {
+      if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
+        return 'URI path must start with "/" when authority is present.';
+      }
+      if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535)) {
+        return "URI port is malformed.";
+      }
+      return void 0;
+    }
+    function parseWithStatus(uri, opts) {
       const options = Object.assign({}, opts);
       const parsed = {
         scheme: void 0,
@@ -26452,6 +26508,7 @@ var require_fast_uri = __commonJS({
         query: void 0,
         fragment: void 0
       };
+      let malformedAuthorityOrPort = false;
       let isIP = false;
       if (options.reference === "suffix") {
         if (options.scheme) {
@@ -26472,6 +26529,11 @@ var require_fast_uri = __commonJS({
         if (isNaN(parsed.port)) {
           parsed.port = matches[5];
         }
+        const parseError = getParseError(parsed, matches);
+        if (parseError !== void 0) {
+          parsed.error = parsed.error || parseError;
+          malformedAuthorityOrPort = true;
+        }
         if (parsed.host) {
           const ipv4result = isIPv4(parsed.host);
           if (ipv4result === false) {
@@ -26510,14 +26572,18 @@ var require_fast_uri = __commonJS({
               parsed.scheme = unescape(parsed.scheme);
             }
             if (parsed.host !== void 0) {
-              parsed.host = unescape(parsed.host);
+              parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
             }
           }
           if (parsed.path) {
-            parsed.path = escape(unescape(parsed.path));
+            parsed.path = normalizePathEncoding(parsed.path);
           }
           if (parsed.fragment) {
-            parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+            try {
+              parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+            } catch {
+              parsed.error = parsed.error || "URI malformed";
+            }
           }
         }
         if (schemeHandler && schemeHandler.parse) {
@@ -26526,7 +26592,29 @@ var require_fast_uri = __commonJS({
       } else {
         parsed.error = parsed.error || "URI can not be parsed.";
       }
-      return parsed;
+      return { parsed, malformedAuthorityOrPort };
+    }
+    function parse3(uri, opts) {
+      return parseWithStatus(uri, opts).parsed;
+    }
+    function normalizeString(uri, opts) {
+      return normalizeStringWithStatus(uri, opts).normalized;
+    }
+    function normalizeStringWithStatus(uri, opts) {
+      const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+      return {
+        normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
+        malformedAuthorityOrPort
+      };
+    }
+    function normalizeComparableURI(uri, opts) {
+      if (typeof uri === "string") {
+        const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
+        return malformedAuthorityOrPort ? void 0 : normalized;
+      }
+      if (typeof uri === "object") {
+        return serialize(uri, opts);
+      }
     }
     var fastUri = {
       SCHEMES,
@@ -31021,7 +31109,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@langwatch/mcp-server",
-      version: "0.7.0",
+      version: "0.9.0",
       description: "An MCP server for Langwatch.",
       type: "module",
       main: "./dist/index.js",
@@ -31063,19 +31151,19 @@ var init_package = __esm({
       },
       devDependencies: {
         "@ai-sdk/anthropic": "^3.0.44",
-        "@anthropic-ai/claude-code": "^2.1.72",
-        "@eslint/js": "^9.4.0",
+        "@anthropic-ai/claude-code": "^2.1.119",
+        "@eslint/js": "^10.0.1",
         "@langwatch/scenario": "^0.4.6",
         "@types/debug": "^4.1.12",
         "@types/eslint__js": "^8.42.3",
         "@types/express": "^5.0.6",
-        "@types/node": "^16.0.0",
+        "@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: "^8.57.0",
+        eslint: "^10.2.1",
         tsup: "^8.1.0",
         tsx: "^4.20.5",
         typescript: "^5.0.0",
@@ -31084,7 +31172,7 @@ var init_package = __esm({
       dependencies: {
         "@modelcontextprotocol/sdk": "^1.26.0",
         "@opentelemetry/context-async-hooks": "^2.1.0",
-        "@opentelemetry/sdk-node": "^0.204.0",
+        "@opentelemetry/sdk-node": "^0.217.0",
         chalk: "^5.6.2",
         "date-fns": "^4.1.0",
         express: "^5.2.1",
@@ -31096,6 +31184,13 @@ var init_package = __esm({
       },
       bin: {
         "langwatch-mcp-server": "./dist/index.js"
+      },
+      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"
+        }
       }
     };
   }
@@ -31133,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, {
@@ -33091,118 +33713,6 @@ var init_discover_schema = __esm({
   }
 });
 
-// src/langwatch-api.ts
-async function makeRequest(method, path, body) {
-  const url2 = getConfig().endpoint + path;
-  const headers = {
-    "X-Auth-Token": requireApiKey()
-  };
-  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();
@@ -35287,72 +35797,6 @@ var init_langwatch_api_secrets = __esm({
   }
 });
 
-// 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");
-}
-var init_run_evaluation = __esm({
-  "src/tools/run-evaluation.ts"() {
-    "use strict";
-    init_langwatch_api();
-  }
-});
-
 // src/langwatch-api-datasets.ts
 async function listDatasets(params) {
   const query = new URLSearchParams();
@@ -35728,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({
@@ -36989,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.",
     {
-      slug: external_exports.string().describe("The evaluation slug to run")
+      runId: external_exports.string().describe("The run ID returned from platform_run_experiment")
     },
-    withToolLogging("platform_run_evaluation", async (params) => {
+    withToolLogging("platform_experiment_status", 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 handleExperimentStatus(params) }]
       };
     })
   );
   server.tool(
-    "platform_evaluation_status",
-    "Check the status of an evaluation run. Returns progress and summary when completed.",
+    "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.",
     {
-      runId: external_exports.string().describe("The run ID returned from platform_run_evaluation")
+      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.",
+    {
+      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_evaluation_status", async (params) => {
+    withToolLogging("platform_experiment_list_runs", 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 handleExperimentListRuns(params) }]
+      };
+    })
+  );
+  server.tool(
+    "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_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_experiment_results", async (params) => {
+      requireApiKey();
+      return {
+        content: [
+          { type: "text", text: await handleExperimentResults(params) }
+        ]
       };
     })
   );
@@ -37171,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({
@@ -37181,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"'
     );
@@ -57102,9 +58040,9 @@ var require_is_promise = __commonJS({
   }
 });
 
-// node_modules/.pnpm/path-to-regexp@8.3.0/node_modules/path-to-regexp/dist/index.js
+// node_modules/.pnpm/path-to-regexp@8.4.2/node_modules/path-to-regexp/dist/index.js
 var require_dist2 = __commonJS({
-  "node_modules/.pnpm/path-to-regexp@8.3.0/node_modules/path-to-regexp/dist/index.js"(exports) {
+  "node_modules/.pnpm/path-to-regexp@8.4.2/node_modules/path-to-regexp/dist/index.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.PathError = exports.TokenData = void 0;
@@ -57117,19 +58055,7 @@ var require_dist2 = __commonJS({
     var NOOP_VALUE = (value) => value;
     var ID_START = /^[$_\p{ID_Start}]$/u;
     var ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u;
-    var SIMPLE_TOKENS = {
-      // Groups.
-      "{": "{",
-      "}": "}",
-      // Reserved.
-      "(": "(",
-      ")": ")",
-      "[": "[",
-      "]": "]",
-      "+": "+",
-      "?": "?",
-      "!": "!"
-    };
+    var ID = /^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u;
     function escapeText(str) {
       return str.replace(/[{}()\[\]+?!:*\\]/g, "\\$&");
     }
@@ -57157,97 +58083,90 @@ var require_dist2 = __commonJS({
     function parse3(str, options = {}) {
       const { encodePath = NOOP_VALUE } = options;
       const chars = [...str];
-      const tokens = [];
       let index = 0;
-      let pos = 0;
-      function name() {
-        let value = "";
-        if (ID_START.test(chars[index])) {
-          do {
-            value += chars[index++];
-          } while (ID_CONTINUE.test(chars[index]));
-        } else if (chars[index] === '"') {
-          let quoteStart = index;
-          while (index++ < chars.length) {
-            if (chars[index] === '"') {
-              index++;
-              quoteStart = 0;
-              break;
-            }
-            if (chars[index] === "\\")
-              index++;
-            value += chars[index];
-          }
-          if (quoteStart) {
-            throw new PathError(`Unterminated quote at index ${quoteStart}`, str);
-          }
-        }
-        if (!value) {
-          throw new PathError(`Missing parameter name at index ${index}`, str);
-        }
-        return value;
-      }
-      while (index < chars.length) {
-        const value = chars[index];
-        const type = SIMPLE_TOKENS[value];
-        if (type) {
-          tokens.push({ type, index: index++, value });
-        } else if (value === "\\") {
-          tokens.push({ type: "escape", index: index++, value: chars[index++] });
-        } else if (value === ":") {
-          tokens.push({ type: "param", index: index++, value: name() });
-        } else if (value === "*") {
-          tokens.push({ type: "wildcard", index: index++, value: name() });
-        } else {
-          tokens.push({ type: "char", index: index++, value });
-        }
-      }
-      tokens.push({ type: "end", index, value: "" });
-      function consumeUntil(endType) {
+      function consumeUntil(end) {
         const output = [];
-        while (true) {
-          const token = tokens[pos++];
-          if (token.type === endType)
-            break;
-          if (token.type === "char" || token.type === "escape") {
-            let path = token.value;
-            let cur = tokens[pos];
-            while (cur.type === "char" || cur.type === "escape") {
-              path += cur.value;
-              cur = tokens[++pos];
+        let path = "";
+        function writePath() {
+          if (!path)
+            return;
+          output.push({
+            type: "text",
+            value: encodePath(path)
+          });
+          path = "";
+        }
+        while (index < chars.length) {
+          const value = chars[index++];
+          if (value === end) {
+            writePath();
+            return output;
+          }
+          if (value === "\\") {
+            if (index === chars.length) {
+              throw new PathError(`Unexpected end after \\ at index ${index}`, str);
             }
-            output.push({
-              type: "text",
-              value: encodePath(path)
-            });
+            path += chars[index++];
             continue;
           }
-          if (token.type === "param" || token.type === "wildcard") {
-            output.push({
-              type: token.type,
-              name: token.value
-            });
+          if (value === ":" || value === "*") {
+            const type = value === ":" ? "param" : "wildcard";
+            let name = "";
+            if (ID_START.test(chars[index])) {
+              do {
+                name += chars[index++];
+              } while (ID_CONTINUE.test(chars[index]));
+            } else if (chars[index] === '"') {
+              let quoteStart = index;
+              while (index < chars.length) {
+                if (chars[++index] === '"') {
+                  index++;
+                  quoteStart = 0;
+                  break;
+                }
+                if (chars[index] === "\\")
+                  index++;
+                name += chars[index];
+              }
+              if (quoteStart) {
+                throw new PathError(`Unterminated quote at index ${quoteStart}`, str);
+              }
+            }
+            if (!name) {
+              throw new PathError(`Missing parameter name at index ${index}`, str);
+            }
+            writePath();
+            output.push({ type, name });
             continue;
           }
-          if (token.type === "{") {
+          if (value === "{") {
+            writePath();
             output.push({
               type: "group",
               tokens: consumeUntil("}")
             });
             continue;
           }
-          throw new PathError(`Unexpected ${token.type} at index ${token.index}, expected ${endType}`, str);
+          if (value === "}" || value === "(" || value === ")" || value === "[" || value === "]" || value === "+" || value === "?" || value === "!") {
+            throw new PathError(`Unexpected ${value} at index ${index - 1}`, str);
+          }
+          path += value;
+        }
+        if (end) {
+          throw new PathError(`Unexpected end at index ${index}, expected ${end}`, str);
         }
+        writePath();
         return output;
       }
-      return new TokenData(consumeUntil("end"), str);
+      return new TokenData(consumeUntil(""), str);
     }
     function compile(path, options = {}) {
       const { encode: encode3 = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
       const data = typeof path === "object" ? path : parse3(path, options);
       const fn = tokensToFunction(data.tokens, delimiter, encode3);
       return function path2(params = {}) {
-        const [path3, ...missing] = fn(params);
+        const missing = [];
+        const path3 = fn(params, missing);
         if (missing.length) {
           throw new TypeError(`Missing parameters: ${missing.join(", ")}`);
         }
@@ -57256,55 +58175,61 @@ var require_dist2 = __commonJS({
     }
     function tokensToFunction(tokens, delimiter, encode3) {
       const encoders = tokens.map((token) => tokenToFunction(token, delimiter, encode3));
-      return (data) => {
-        const result = [""];
+      return (data, missing) => {
+        let result = "";
         for (const encoder of encoders) {
-          const [value, ...extras] = encoder(data);
-          result[0] += value;
-          result.push(...extras);
+          result += encoder(data, missing);
         }
         return result;
       };
     }
     function tokenToFunction(token, delimiter, encode3) {
       if (token.type === "text")
-        return () => [token.value];
+        return () => token.value;
       if (token.type === "group") {
         const fn = tokensToFunction(token.tokens, delimiter, encode3);
-        return (data) => {
-          const [value, ...missing] = fn(data);
-          if (!missing.length)
-            return [value];
-          return [""];
+        return (data, missing) => {
+          const len = missing.length;
+          const value = fn(data, missing);
+          if (missing.length === len)
+            return value;
+          missing.length = len;
+          return "";
         };
       }
       const encodeValue = encode3 || NOOP_VALUE;
       if (token.type === "wildcard" && encode3 !== false) {
-        return (data) => {
+        return (data, missing) => {
           const value = data[token.name];
-          if (value == null)
-            return ["", token.name];
+          if (value == null) {
+            missing.push(token.name);
+            return "";
+          }
           if (!Array.isArray(value) || value.length === 0) {
             throw new TypeError(`Expected "${token.name}" to be a non-empty array`);
           }
-          return [
-            value.map((value2, index) => {
-              if (typeof value2 !== "string") {
-                throw new TypeError(`Expected "${token.name}/${index}" to be a string`);
-              }
-              return encodeValue(value2);
-            }).join(delimiter)
-          ];
+          let result = "";
+          for (let i = 0; i < value.length; i++) {
+            if (typeof value[i] !== "string") {
+              throw new TypeError(`Expected "${token.name}/${i}" to be a string`);
+            }
+            if (i > 0)
+              result += delimiter;
+            result += encodeValue(value[i]);
+          }
+          return result;
         };
       }
-      return (data) => {
+      return (data, missing) => {
         const value = data[token.name];
-        if (value == null)
-          return ["", token.name];
+        if (value == null) {
+          missing.push(token.name);
+          return "";
+        }
         if (typeof value !== "string") {
           throw new TypeError(`Expected "${token.name}" to be a string`);
         }
-        return [encodeValue(value)];
+        return encodeValue(value);
       };
     }
     function match(path, options = {}) {
@@ -57336,106 +58261,134 @@ var require_dist2 = __commonJS({
     function pathToRegexp(path, options = {}) {
       const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true } = options;
       const keys = [];
-      const flags = sensitive ? "" : "i";
-      const sources = [];
-      for (const input of pathsToArray(path, [])) {
-        const data = typeof input === "object" ? input : parse3(input, options);
-        for (const tokens of flatten(data.tokens, 0, [])) {
-          sources.push(toRegExpSource(tokens, delimiter, keys, data.originalPath));
+      let source = "";
+      let combinations = 0;
+      function process4(path2) {
+        if (Array.isArray(path2)) {
+          for (const p of path2)
+            process4(p);
+          return;
         }
+        const data = typeof path2 === "object" ? path2 : parse3(path2, options);
+        flatten(data.tokens, 0, [], (tokens) => {
+          if (combinations >= 256) {
+            throw new PathError("Too many path combinations", data.originalPath);
+          }
+          if (combinations > 0)
+            source += "|";
+          source += toRegExpSource(tokens, delimiter, keys, data.originalPath);
+          combinations++;
+        });
       }
-      let pattern = `^(?:${sources.join("|")})`;
+      process4(path);
+      let pattern = `^(?:${source})`;
       if (trailing)
-        pattern += `(?:${escape2(delimiter)}$)?`;
-      pattern += end ? "$" : `(?=${escape2(delimiter)}|$)`;
-      const regexp = new RegExp(pattern, flags);
-      return { regexp, keys };
-    }
-    function pathsToArray(paths, init) {
-      if (Array.isArray(paths)) {
-        for (const p of paths)
-          pathsToArray(p, init);
-      } else {
-        init.push(paths);
-      }
-      return init;
+        pattern += "(?:" + escape2(delimiter) + "$)?";
+      pattern += end ? "$" : "(?=" + escape2(delimiter) + "|$)";
+      return { regexp: new RegExp(pattern, sensitive ? "" : "i"), keys };
     }
-    function* flatten(tokens, index, init) {
-      if (index === tokens.length) {
-        return yield init;
-      }
-      const token = tokens[index];
-      if (token.type === "group") {
-        for (const seq of flatten(token.tokens, 0, init.slice())) {
-          yield* flatten(tokens, index + 1, seq);
+    function flatten(tokens, index, result, callback) {
+      while (index < tokens.length) {
+        const token = tokens[index++];
+        if (token.type === "group") {
+          const len = result.length;
+          flatten(token.tokens, 0, result, (seq) => flatten(tokens, index, seq, callback));
+          result.length = len;
+          continue;
         }
-      } else {
-        init.push(token);
+        result.push(token);
       }
-      yield* flatten(tokens, index + 1, init);
+      callback(result);
     }
     function toRegExpSource(tokens, delimiter, keys, originalPath) {
       let result = "";
       let backtrack = "";
-      let isSafeSegmentParam = true;
-      for (const token of tokens) {
+      let wildcardBacktrack = "";
+      let prevCaptureType = 0;
+      let hasSegmentCapture = 0;
+      let index = 0;
+      function hasInSegment(index2, type) {
+        while (index2 < tokens.length) {
+          const token = tokens[index2++];
+          if (token.type === type)
+            return true;
+          if (token.type === "text") {
+            if (token.value.includes(delimiter))
+              break;
+          }
+        }
+        return false;
+      }
+      function peekText(index2) {
+        let result2 = "";
+        while (index2 < tokens.length) {
+          const token = tokens[index2++];
+          if (token.type !== "text")
+            break;
+          result2 += token.value;
+        }
+        return result2;
+      }
+      while (index < tokens.length) {
+        const token = tokens[index++];
         if (token.type === "text") {
           result += escape2(token.value);
           backtrack += token.value;
-          isSafeSegmentParam || (isSafeSegmentParam = token.value.includes(delimiter));
+          if (prevCaptureType === 2)
+            wildcardBacktrack += token.value;
+          if (token.value.includes(delimiter))
+            hasSegmentCapture = 0;
           continue;
         }
         if (token.type === "param" || token.type === "wildcard") {
-          if (!isSafeSegmentParam && !backtrack) {
+          if (prevCaptureType && !backtrack) {
             throw new PathError(`Missing text before "${token.name}" ${token.type}`, originalPath);
           }
           if (token.type === "param") {
-            result += `(${negate(delimiter, isSafeSegmentParam ? "" : backtrack)}+)`;
+            result += hasSegmentCapture & 2 ? `(${negate(delimiter, backtrack)}+)` : hasInSegment(index, "wildcard") ? `(${negate(delimiter, peekText(index))}+)` : hasSegmentCapture & 1 ? `(${negate(delimiter, backtrack)}+|${escape2(backtrack)})` : `(${negate(delimiter, "")}+)`;
+            hasSegmentCapture |= prevCaptureType = 1;
           } else {
-            result += `([\\s\\S]+)`;
+            result += hasSegmentCapture & 2 ? `(${negate(backtrack, "")}+)` : wildcardBacktrack ? `(${negate(wildcardBacktrack, "")}+|${negate(delimiter, "")}+)` : `([^]+)`;
+            wildcardBacktrack = "";
+            hasSegmentCapture |= prevCaptureType = 2;
           }
           keys.push(token);
           backtrack = "";
-          isSafeSegmentParam = false;
           continue;
         }
+        throw new TypeError(`Unknown token type: ${token.type}`);
       }
       return result;
     }
-    function negate(delimiter, backtrack) {
-      if (backtrack.length < 2) {
-        if (delimiter.length < 2)
-          return `[^${escape2(delimiter + backtrack)}]`;
-        return `(?:(?!${escape2(delimiter)})[^${escape2(backtrack)}])`;
-      }
-      if (delimiter.length < 2) {
-        return `(?:(?!${escape2(backtrack)})[^${escape2(delimiter)}])`;
-      }
-      return `(?:(?!${escape2(backtrack)}|${escape2(delimiter)})[\\s\\S])`;
-    }
-    function stringifyTokens(tokens) {
+    function negate(a, b) {
+      if (b.length > a.length)
+        return negate(b, a);
+      if (a === b)
+        b = "";
+      if (b.length > 1)
+        return `(?:(?!${escape2(a)}|${escape2(b)})[^])`;
+      if (a.length > 1)
+        return `(?:(?!${escape2(a)})[^${escape2(b)}])`;
+      return `[^${escape2(a + b)}]`;
+    }
+    function stringifyTokens(tokens, index) {
       let value = "";
-      let i = 0;
-      function name(value2) {
-        const isSafe = isNameSafe(value2) && isNextNameSafe(tokens[i]);
-        return isSafe ? value2 : JSON.stringify(value2);
-      }
-      while (i < tokens.length) {
-        const token = tokens[i++];
+      while (index < tokens.length) {
+        const token = tokens[index++];
         if (token.type === "text") {
           value += escapeText(token.value);
           continue;
         }
         if (token.type === "group") {
-          value += `{${stringifyTokens(token.tokens)}}`;
+          value += "{" + stringifyTokens(token.tokens, 0) + "}";
           continue;
         }
         if (token.type === "param") {
-          value += `:${name(token.name)}`;
+          value += ":" + stringifyName(token.name, tokens[index]);
           continue;
         }
         if (token.type === "wildcard") {
-          value += `*${name(token.name)}`;
+          value += "*" + stringifyName(token.name, tokens[index]);
           continue;
         }
         throw new TypeError(`Unknown token type: ${token.type}`);
@@ -57443,16 +58396,15 @@ var require_dist2 = __commonJS({
       return value;
     }
     function stringify(data) {
-      return stringifyTokens(data.tokens);
+      return stringifyTokens(data.tokens, 0);
     }
-    function isNameSafe(name) {
-      const [first, ...rest] = name;
-      return ID_START.test(first) && rest.every((char) => ID_CONTINUE.test(char));
-    }
-    function isNextNameSafe(token) {
-      if (token && token.type === "text")
-        return !ID_CONTINUE.test(token.value[0]);
-      return true;
+    function stringifyName(name, next) {
+      if (!ID.test(name))
+        return JSON.stringify(name);
+      if ((next === null || next === void 0 ? void 0 : next.type) === "text" && ID_CONTINUE.test(next.value[0])) {
+        return JSON.stringify(name);
+      }
+      return name;
     }
   }
 });
@@ -60806,8 +61758,8 @@ var require_express2 = __commonJS({
   }
 });
 
-// node_modules/.pnpm/@hono+node-server@1.19.11_hono@4.12.5/node_modules/@hono/node-server/dist/index.mjs
-import { Http2ServerRequest as Http2ServerRequest2 } from "http2";
+// node_modules/.pnpm/@hono+node-server@1.19.14_hono@4.12.14/node_modules/@hono/node-server/dist/index.mjs
+import { Http2ServerRequest as Http2ServerRequest2, constants as h2constants } from "http2";
 import { Http2ServerRequest } from "http2";
 import { Readable } from "stream";
 import crypto2 from "crypto";
@@ -60856,9 +61808,9 @@ function writeFromReadableStream(stream, writable) {
   }
   return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
 }
-var RequestError, toRequestError, GlobalRequest, Request, newHeadersFromIncoming, wrapBodyStream, newRequestFromIncoming, getRequestCache, requestCache, incomingKey, urlKey, headersKey, abortControllerKey, getAbortController, requestPrototype, newRequest, responseCache, getResponseCache, cacheKey, GlobalResponse, Response2, buildOutgoingHttpHeaders, X_ALREADY_SENT, outgoingEnded, handleRequestError, handleFetchError, handleResponseError, flushHeaders, responseViaCache, isPromise2, responseViaResponseObject, getRequestListener;
+var RequestError, toRequestError, GlobalRequest, Request, newHeadersFromIncoming, wrapBodyStream, newRequestFromIncoming, getRequestCache, requestCache, incomingKey, urlKey, headersKey, abortControllerKey, getAbortController, requestPrototype, newRequest, responseCache, getResponseCache, cacheKey, GlobalResponse, Response2, buildOutgoingHttpHeaders, X_ALREADY_SENT, outgoingEnded, incomingDraining, DRAIN_TIMEOUT_MS, MAX_DRAIN_BYTES, drainIncoming, handleRequestError, handleFetchError, handleResponseError, flushHeaders, responseViaCache, isPromise2, responseViaResponseObject, getRequestListener;
 var init_dist = __esm({
-  "node_modules/.pnpm/@hono+node-server@1.19.11_hono@4.12.5/node_modules/@hono/node-server/dist/index.mjs"() {
+  "node_modules/.pnpm/@hono+node-server@1.19.14_hono@4.12.14/node_modules/@hono/node-server/dist/index.mjs"() {
     RequestError = class extends Error {
       constructor(message, options) {
         super(message, options);
@@ -61003,6 +61955,17 @@ var init_dist = __esm({
         }
       });
     });
+    Object.defineProperty(requestPrototype, Symbol.for("nodejs.util.inspect.custom"), {
+      value: function(depth, options, inspectFn) {
+        const props = {
+          method: this.method,
+          url: this.url,
+          headers: this.headers,
+          nativeRequest: this[requestCache]
+        };
+        return `Request (lightweight) ${inspectFn(props, { ...options, depth: depth == null ? null : depth - 1 })}`;
+      }
+    });
     Object.setPrototypeOf(requestPrototype, Request.prototype);
     newRequest = (incoming, defaultHostname) => {
       const req = Object.create(requestPrototype);
@@ -61107,6 +62070,17 @@ var init_dist = __esm({
         }
       });
     });
+    Object.defineProperty(Response2.prototype, Symbol.for("nodejs.util.inspect.custom"), {
+      value: function(depth, options, inspectFn) {
+        const props = {
+          status: this.status,
+          headers: this.headers,
+          ok: this.ok,
+          nativeResponse: this[responseCache]
+        };
+        return `Response (lightweight) ${inspectFn(props, { ...options, depth: depth == null ? null : depth - 1 })}`;
+      }
+    });
     Object.setPrototypeOf(Response2, GlobalResponse);
     Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
     buildOutgoingHttpHeaders = (headers) => {
@@ -61133,6 +62107,50 @@ var init_dist = __esm({
       global.crypto = crypto2;
     }
     outgoingEnded = Symbol("outgoingEnded");
+    incomingDraining = Symbol("incomingDraining");
+    DRAIN_TIMEOUT_MS = 500;
+    MAX_DRAIN_BYTES = 64 * 1024 * 1024;
+    drainIncoming = (incoming) => {
+      const incomingWithDrainState = incoming;
+      if (incoming.destroyed || incomingWithDrainState[incomingDraining]) {
+        return;
+      }
+      incomingWithDrainState[incomingDraining] = true;
+      if (incoming instanceof Http2ServerRequest2) {
+        try {
+          ;
+          incoming.stream?.close?.(h2constants.NGHTTP2_NO_ERROR);
+        } catch {
+        }
+        return;
+      }
+      let bytesRead = 0;
+      const cleanup = () => {
+        clearTimeout(timer);
+        incoming.off("data", onData);
+        incoming.off("end", cleanup);
+        incoming.off("error", cleanup);
+      };
+      const forceClose = () => {
+        cleanup();
+        const socket = incoming.socket;
+        if (socket && !socket.destroyed) {
+          socket.destroySoon();
+        }
+      };
+      const timer = setTimeout(forceClose, DRAIN_TIMEOUT_MS);
+      timer.unref?.();
+      const onData = (chunk) => {
+        bytesRead += chunk.length;
+        if (bytesRead > MAX_DRAIN_BYTES) {
+          forceClose();
+        }
+      };
+      incoming.on("data", onData);
+      incoming.on("end", cleanup);
+      incoming.on("error", cleanup);
+      incoming.resume();
+    };
     handleRequestError = () => new Response(null, {
       status: 400
     });
@@ -61304,14 +62322,18 @@ var init_dist = __esm({
                   setTimeout(() => {
                     if (!incomingEnded) {
                       setTimeout(() => {
-                        incoming.destroy();
-                        outgoing.destroy();
+                        drainIncoming(incoming);
                       });
                     }
                   });
                 }
               };
             }
+            outgoing.on("finish", () => {
+              if (!incomingEnded) {
+                drainIncoming(incoming);
+              }
+            });
           }
           outgoing.on("close", () => {
             const abortController = req[abortControllerKey];
@@ -61326,7 +62348,7 @@ var init_dist = __esm({
               setTimeout(() => {
                 if (!incomingEnded) {
                   setTimeout(() => {
-                    incoming.destroy();
+                    drainIncoming(incoming);
                   });
                 }
               });