@langwatch/mcp-server 2.2.0 → 3.0.0

package/dist/create-mcp-server.cjs

@@ -31,7 +31,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@langwatch/mcp-server",
-      version: "2.2.0",
+      version: "3.0.0",
       description: "An MCP server for Langwatch.",
       license: "MIT",
       author: "",
@@ -590,11 +590,15 @@ async function makeRequest(method, path, body) {
   const url = config.endpoint + path;
   const headers = {
     ...MCP_IDENTITY_HEADERS,
+    "X-API-Version": LANGWATCH_API_VERSION,
     "X-Auth-Token": requireApiKey()
   };
   if (config.projectId) {
     headers["X-Project-Id"] = config.projectId;
   }
+  if (config.hosted) {
+    headers[HOSTED_MCP_HEADER] = "hosted";
+  }
   if (body !== void 0) {
     headers["Content-Type"] = "application/json";
   }
@@ -705,7 +709,7 @@ async function renamePromptTag({
 async function deletePromptTag(tag) {
   return makeRequest("DELETE", `/api/v1/prompts/tags/${encodeURIComponent(tag)}`);
 }
-var MCP_IDENTITY_HEADERS, LangWatchApiError, VALID_FAULTS;
+var MCP_IDENTITY_HEADERS, LANGWATCH_API_VERSION, HOSTED_MCP_HEADER, LangWatchApiError, VALID_FAULTS;
 var init_langwatch_api = __esm({
   "src/langwatch-api.ts"() {
     "use strict";
@@ -717,6 +721,8 @@ var init_langwatch_api = __esm({
       "X-LangWatch-SDK-Language": "typescript",
       "X-LangWatch-SDK-Version": package_default.version
     };
+    LANGWATCH_API_VERSION = "2026-10-26";
+    HOSTED_MCP_HEADER = "X-LangWatch-MCP-Host";
     LangWatchApiError = class extends Error {
       constructor(message, status, responseBody, options = {}) {
         super(message);
@@ -1287,16 +1293,16 @@ async function runAgent({
 async function deleteAgent(id) {
   return makeRequest("DELETE", `/api/v1/agents/${encodeURIComponent(id)}`);
 }
-var import_zod5, agentCallParamsSchema, isMessageList;
+var import_zod6, agentCallParamsSchema, isMessageList;
 var init_langwatch_api_agents = __esm({
   "src/langwatch-api-agents.ts"() {
     "use strict";
-    import_zod5 = require("zod");
+    import_zod6 = require("zod");
     init_langwatch_api();
     init_public_http_request();
-    agentCallParamsSchema = import_zod5.z.record(
-      import_zod5.z.string(),
-      import_zod5.z.union([import_zod5.z.string(), import_zod5.z.number(), import_zod5.z.boolean()])
+    agentCallParamsSchema = import_zod6.z.record(
+      import_zod6.z.string(),
+      import_zod6.z.union([import_zod6.z.string(), import_zod6.z.number(), import_zod6.z.boolean()])
     );
     isMessageList = (value) => Array.isArray(value) && value.every(
       (item) => typeof item === "object" && item !== null && typeof item.role === "string"
@@ -1509,8 +1515,23 @@ function isKeyShapedBody(body) {
   }
   const { lower, upper, digit } = countCharClasses(body);
   if (lower < 2 || upper < 2 || digit < 2) return false;
+  if (isWordSlug(body)) return false;
   return shannonEntropyBits(body) >= SHAPED_TOKEN_MIN_ENTROPY;
 }
+function isWordSlug(body) {
+  const segments = body.split(/[-_]/);
+  if (segments.length < SLUG_MIN_SEGMENTS) return false;
+  let words = 0;
+  let randomLooking = 0;
+  for (const segment of segments) {
+    if (!SLUG_LETTERS_SEGMENT.test(segment) && !SLUG_TAG_SEGMENT.test(segment)) {
+      return false;
+    }
+    if (SLUG_WORD_SEGMENT.test(segment)) words += 1;
+    if (SLUG_RANDOM_SEGMENT.test(segment)) randomLooking += 1;
+  }
+  return words >= SLUG_MIN_WORDS && randomLooking <= SLUG_MAX_RANDOM_SEGMENTS;
+}
 function isNonCredentialPrefix(prefix) {
   const lower = prefix.toLowerCase();
   return DIGEST_PREFIXES.has(lower) || IDENTIFIER_PREFIXES.has(lower) || RECORD_ID_PREFIXES.has(lower) || PUBLIC_KEY_PREFIXES.has(lower);
@@ -1649,7 +1670,7 @@ function redactOneSlice(text, customPatterns, skipped) {
   }
   return { text: result, redactedCount };
 }
-var SECRETS_REDACTION_MARKER, REPLACEMENT, MAX_SCAN_LENGTH, ENTROPY_SAMPLE_LENGTH, TOKEN_START, TOKEN_END, VENDOR_KEY_PATTERNS, VENDOR_KEY_REGEX, SHAPED_TOKEN_MIN_BODY, SHAPED_TOKEN_MAX_BODY, SHAPED_TOKEN_MIN_ENTROPY, DIGEST_PREFIXES, HEX_BODY_CREDENTIAL_SEGMENTS, IDENTIFIER_PREFIXES, RECORD_ID_PREFIXES, PUBLIC_KEY_PREFIXES, HEX_BODY_MIN, HEX_BODY_MAX, PLACEHOLDER_VALUE_REGEX, ENV_REFERENCE_REGEX, CODE_EXPRESSION_REGEX, PATH_LIKE_REGEX, CONTEXT_VALUE_MIN_LENGTH, CONTEXT_VALUE_MIN_ENTROPY, VERSION_STRING_REGEX, LOOSE_VALUE_MIN_LENGTH, LOOSE_VALUE_MIN_ENTROPY, CREDENTIAL_QUALIFIERS, QUALIFIER_ALTERNATION, CREDENTIAL_KEYWORD, VALUE_RULES, BUILTIN_SECRET_RULES, SENSITIVE_KEY_REGEX, CREDENTIAL_NOUNS, VALUE_BOUNDARY, CUSTOM_VALUE_BOUNDARY, SAFE_CUT_LOOKAHEAD, PEM_BEGIN, PEM_END;
+var SECRETS_REDACTION_MARKER, REPLACEMENT, MAX_SCAN_LENGTH, ENTROPY_SAMPLE_LENGTH, TOKEN_START, TOKEN_END, VENDOR_KEY_PATTERNS, VENDOR_KEY_REGEX, SHAPED_TOKEN_MIN_BODY, SHAPED_TOKEN_MAX_BODY, SHAPED_TOKEN_MIN_ENTROPY, SLUG_MIN_SEGMENTS, SLUG_LETTERS_SEGMENT, SLUG_TAG_SEGMENT, SLUG_WORD_SEGMENT, SLUG_RANDOM_SEGMENT, SLUG_MAX_RANDOM_SEGMENTS, SLUG_MIN_WORDS, DIGEST_PREFIXES, HEX_BODY_CREDENTIAL_SEGMENTS, IDENTIFIER_PREFIXES, RECORD_ID_PREFIXES, PUBLIC_KEY_PREFIXES, HEX_BODY_MIN, HEX_BODY_MAX, PLACEHOLDER_VALUE_REGEX, ENV_REFERENCE_REGEX, CODE_EXPRESSION_REGEX, PATH_LIKE_REGEX, CONTEXT_VALUE_MIN_LENGTH, CONTEXT_VALUE_MIN_ENTROPY, VERSION_STRING_REGEX, LOOSE_VALUE_MIN_LENGTH, LOOSE_VALUE_MIN_ENTROPY, CREDENTIAL_QUALIFIERS, QUALIFIER_ALTERNATION, CREDENTIAL_KEYWORD, VALUE_RULES, BUILTIN_SECRET_RULES, SENSITIVE_KEY_REGEX, CREDENTIAL_NOUNS, VALUE_BOUNDARY, CUSTOM_VALUE_BOUNDARY, SAFE_CUT_LOOKAHEAD, PEM_BEGIN, PEM_END;
 var init_secrets = __esm({
   "../../packages/redaction/src/secrets.ts"() {
     "use strict";
@@ -1715,6 +1736,13 @@ var init_secrets = __esm({
     SHAPED_TOKEN_MIN_BODY = 26;
     SHAPED_TOKEN_MAX_BODY = 120;
     SHAPED_TOKEN_MIN_ENTROPY = 3.9;
+    SLUG_MIN_SEGMENTS = 4;
+    SLUG_LETTERS_SEGMENT = /^[A-Za-z]{1,12}$/;
+    SLUG_TAG_SEGMENT = /^[A-Za-z0-9]{1,6}$/;
+    SLUG_WORD_SEGMENT = /^(?:[a-z]{4,}|[A-Z]{4,}|[A-Z][a-z]{3,})$/;
+    SLUG_RANDOM_SEGMENT = /^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])/;
+    SLUG_MAX_RANDOM_SEGMENTS = 1;
+    SLUG_MIN_WORDS = 2;
     DIGEST_PREFIXES = /* @__PURE__ */ new Set([
       "sha1",
       "sha224",
@@ -2290,6 +2318,7 @@ async function deliverReport(report, params) {
     method: "POST",
     headers: {
       "content-type": "application/json",
+      "x-api-version": LANGWATCH_API_VERSION,
       ...config.apiKey ? { authorization: `Bearer ${config.apiKey}` } : {}
     },
     body: JSON.stringify({
@@ -2342,6 +2371,7 @@ var init_report_issue = __esm({
     "use strict";
     init_src();
     init_config();
+    init_langwatch_api();
     MAX_SESSION_BYTES = 8 * 1024 * 1024;
     REQUEST_TIMEOUT_MS2 = 6e4;
   }
@@ -5240,318 +5270,268 @@ async function handleRunAgent({
   }
   return lines.join("\n");
 }
-var import_zod6, jsonObjectSchema;
+var import_zod7, jsonObjectSchema;
 var init_run_agent = __esm({
   "src/tools/run-agent.ts"() {
     "use strict";
-    import_zod6 = require("zod");
+    import_zod7 = require("zod");
     init_langwatch_api_agents();
-    jsonObjectSchema = import_zod6.z.looseObject({});
+    jsonObjectSchema = import_zod7.z.looseObject({});
   }
 });
 
-// src/langwatch-api-dashboards.ts
-var langwatch_api_dashboards_exports = {};
-__export(langwatch_api_dashboards_exports, {
-  createDashboard: () => createDashboard,
-  deleteDashboard: () => deleteDashboard,
-  getDashboard: () => getDashboard,
-  listDashboards: () => listDashboards,
-  renameDashboard: () => renameDashboard
+// src/langwatch-api-analytics-reports.ts
+var langwatch_api_analytics_reports_exports = {};
+__export(langwatch_api_analytics_reports_exports, {
+  createAnalyticsReport: () => createAnalyticsReport,
+  deleteAnalyticsReport: () => deleteAnalyticsReport,
+  getAnalyticsReport: () => getAnalyticsReport,
+  listAnalyticsReports: () => listAnalyticsReports,
+  renameAnalyticsReport: () => renameAnalyticsReport
 });
-async function listDashboards() {
-  return makeRequest("GET", "/api/v1/dashboards");
+async function listAnalyticsReports() {
+  return makeRequest("GET", "/api/v1/analytics/reports");
 }
-async function getDashboard(id) {
-  return makeRequest(
-    "GET",
-    `/api/v1/dashboards/${encodeURIComponent(id)}`
-  );
+async function getAnalyticsReport({
+  reportId
+}) {
+  return makeRequest("GET", reportPath(reportId));
 }
-async function createDashboard(data) {
-  return makeRequest("POST", "/api/v1/dashboards", data);
+async function createAnalyticsReport({
+  name
+}) {
+  return makeRequest("POST", "/api/v1/analytics/reports", {
+    name
+  });
 }
-async function renameDashboard(id, data) {
-  return makeRequest(
-    "PATCH",
-    `/api/v1/dashboards/${encodeURIComponent(id)}`,
-    data
-  );
+async function renameAnalyticsReport({
+  reportId,
+  name
+}) {
+  return makeRequest("PATCH", reportPath(reportId), { name });
 }
-async function deleteDashboard(id) {
-  return makeRequest("DELETE", `/api/v1/dashboards/${encodeURIComponent(id)}`);
+async function deleteAnalyticsReport({
+  reportId
+}) {
+  return makeRequest("DELETE", reportPath(reportId));
 }
-var init_langwatch_api_dashboards = __esm({
-  "src/langwatch-api-dashboards.ts"() {
+var reportPath;
+var init_langwatch_api_analytics_reports = __esm({
+  "src/langwatch-api-analytics-reports.ts"() {
     "use strict";
     init_langwatch_api();
+    reportPath = (reportId) => `/api/v1/analytics/reports/${encodeURIComponent(reportId)}`;
   }
 });
 
-// src/tools/list-dashboards.ts
-var list_dashboards_exports = {};
-__export(list_dashboards_exports, {
-  handleListDashboards: () => handleListDashboards
+// src/tools/list-analytics-reports.ts
+var list_analytics_reports_exports = {};
+__export(list_analytics_reports_exports, {
+  handleListAnalyticsReports: () => handleListAnalyticsReports
 });
-async function handleListDashboards() {
-  const result = await listDashboards();
-  const dashboards = result.data;
-  if (!Array.isArray(dashboards) || dashboards.length === 0) {
-    return "No dashboards found in this project.\n\n> Tip: Use `platform_create_dashboard` to create a new dashboard.";
+async function handleListAnalyticsReports() {
+  const result = await listAnalyticsReports();
+  const reports = result.data;
+  if (!Array.isArray(reports) || reports.length === 0) {
+    return "No Analytics Reports found in this project.\n\n> Tip: Use `platform_create_analytics_report` to create a new Analytics Report.";
   }
   const lines = [];
-  lines.push(`# Dashboards (${dashboards.length} total)
+  lines.push(`# Analytics Reports (${reports.length} total)
 `);
-  for (const d of dashboards) {
-    lines.push(`## ${d.name}`);
-    lines.push(`**ID**: ${d.id}`);
-    lines.push(`**Graphs**: ${d.graphCount}`);
-    lines.push(`**Updated**: ${d.updatedAt}`);
+  for (const report of reports) {
+    lines.push(`## ${report.name}`);
+    lines.push(`**ID**: ${report.id}`);
+    lines.push(`**Graphs**: ${report.graphCount}`);
+    lines.push(`**Updated**: ${report.updatedAt}`);
     lines.push("");
   }
   lines.push(
-    "> Use `platform_get_dashboard` with the ID to see dashboard details including graphs."
+    "> Use `platform_get_analytics_report` with the ID to see the Analytics Report's details including graphs."
   );
   return lines.join("\n");
 }
-var init_list_dashboards = __esm({
-  "src/tools/list-dashboards.ts"() {
+var init_list_analytics_reports = __esm({
+  "src/tools/list-analytics-reports.ts"() {
     "use strict";
-    init_langwatch_api_dashboards();
+    init_langwatch_api_analytics_reports();
   }
 });
 
-// src/tools/get-dashboard.ts
-var get_dashboard_exports = {};
-__export(get_dashboard_exports, {
-  handleGetDashboard: () => handleGetDashboard
+// src/tools/get-analytics-report.ts
+var get_analytics_report_exports = {};
+__export(get_analytics_report_exports, {
+  handleGetAnalyticsReport: () => handleGetAnalyticsReport
 });
-async function handleGetDashboard(params) {
-  const dashboard = await getDashboard(params.id);
+async function handleGetAnalyticsReport(params) {
+  const report = await getAnalyticsReport({ reportId: params.reportId });
   const lines = [];
-  lines.push(`# ${dashboard.name}
+  lines.push(`# ${report.name}
 `);
-  lines.push(`**ID**: ${dashboard.id}`);
-  lines.push(`**Order**: ${dashboard.order}`);
-  lines.push(`**Graphs**: ${Array.isArray(dashboard.graphs) ? dashboard.graphs.length : 0}`);
-  lines.push(`**Created**: ${dashboard.createdAt}`);
-  lines.push(`**Updated**: ${dashboard.updatedAt}`);
-  if (Array.isArray(dashboard.graphs) && dashboard.graphs.length > 0) {
+  lines.push(`**ID**: ${report.id}`);
+  lines.push(`**Order**: ${report.order}`);
+  lines.push(`**Graphs**: ${Array.isArray(report.graphs) ? report.graphs.length : 0}`);
+  lines.push(`**Created**: ${report.createdAt}`);
+  lines.push(`**Updated**: ${report.updatedAt}`);
+  if (Array.isArray(report.graphs) && report.graphs.length > 0) {
     lines.push("\n## Graphs\n");
     lines.push("```json");
-    lines.push(JSON.stringify(dashboard.graphs, null, 2));
+    lines.push(JSON.stringify(report.graphs, null, 2));
     lines.push("```");
   }
   return lines.join("\n");
 }
-var init_get_dashboard = __esm({
-  "src/tools/get-dashboard.ts"() {
+var init_get_analytics_report = __esm({
+  "src/tools/get-analytics-report.ts"() {
     "use strict";
-    init_langwatch_api_dashboards();
+    init_langwatch_api_analytics_reports();
   }
 });
 
-// src/tools/create-dashboard.ts
-var create_dashboard_exports = {};
-__export(create_dashboard_exports, {
-  handleCreateDashboard: () => handleCreateDashboard
+// src/tools/create-analytics-report.ts
+var create_analytics_report_exports = {};
+__export(create_analytics_report_exports, {
+  handleCreateAnalyticsReport: () => handleCreateAnalyticsReport
 });
-async function handleCreateDashboard(params) {
-  const dashboard = await createDashboard({ name: params.name });
-  return `Dashboard created successfully!
+async function handleCreateAnalyticsReport(params) {
+  const report = await createAnalyticsReport({ name: params.name });
+  return `Analytics Report created successfully!
 
-**Name**: ${dashboard.name}
-**ID**: ${dashboard.id}`;
+**Name**: ${report.name}
+**ID**: ${report.id}`;
 }
-var init_create_dashboard = __esm({
-  "src/tools/create-dashboard.ts"() {
+var init_create_analytics_report = __esm({
+  "src/tools/create-analytics-report.ts"() {
     "use strict";
-    init_langwatch_api_dashboards();
+    init_langwatch_api_analytics_reports();
   }
 });
 
-// src/tools/delete-dashboard.ts
-var delete_dashboard_exports = {};
-__export(delete_dashboard_exports, {
-  handleDeleteDashboard: () => handleDeleteDashboard
+// src/tools/delete-analytics-report.ts
+var delete_analytics_report_exports = {};
+__export(delete_analytics_report_exports, {
+  handleDeleteAnalyticsReport: () => handleDeleteAnalyticsReport
 });
-async function handleDeleteDashboard(params) {
-  const result = await deleteDashboard(params.id);
-  return `Dashboard deleted successfully!
+async function handleDeleteAnalyticsReport(params) {
+  const result = await deleteAnalyticsReport({ reportId: params.reportId });
+  return `Analytics Report deleted successfully!
 
 **Name**: ${result.name}
 **ID**: ${result.id}`;
 }
-var init_delete_dashboard = __esm({
-  "src/tools/delete-dashboard.ts"() {
+var init_delete_analytics_report = __esm({
+  "src/tools/delete-analytics-report.ts"() {
     "use strict";
-    init_langwatch_api_dashboards();
+    init_langwatch_api_analytics_reports();
   }
 });
 
-// src/langwatch-api-boards.ts
-async function listBoards({
-  projectId: projectId2
+// src/langwatch-api-dashboards.ts
+async function listDashboards() {
+  return makeRequest("GET", "/api/v1/dashboards");
+}
+async function getDashboard({ dashboardId }) {
+  return makeRequest("GET", dashboardPath(dashboardId));
+}
+async function createDashboard({ name }) {
+  return makeRequest("POST", "/api/v1/dashboards", { name });
+}
+async function updateDashboard({
+  dashboardId,
+  ...changes
 }) {
-  return makeRequest(
-    "GET",
-    `/api/v1/projects/${encodeURIComponent(projectId2)}/analytics/boards`
-  );
+  return makeRequest("PATCH", dashboardPath(dashboardId), changes);
 }
-async function getBoard({
-  projectId: projectId2,
-  boardId
+async function deleteDashboard({
+  dashboardId
 }) {
-  return makeRequest(
-    "GET",
-    `/api/v1/projects/${encodeURIComponent(projectId2)}/analytics/boards/${encodeURIComponent(boardId)}`
-  );
+  return makeRequest("DELETE", dashboardPath(dashboardId));
 }
-var init_langwatch_api_boards = __esm({
-  "src/langwatch-api-boards.ts"() {
-    "use strict";
-    init_langwatch_api();
-  }
-});
-
-// 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/v1/projects${qs}`);
+async function listWidgetsOnDashboard({
+  dashboardId
+}) {
+  return makeRequest("GET", `${dashboardPath(dashboardId)}/widgets`);
 }
-async function getProject(id) {
+async function createWidgetOnDashboard({
+  dashboardId,
+  ...data
+}) {
   return makeRequest(
-    "GET",
-    `/api/v1/projects/${encodeURIComponent(id)}`
+    "POST",
+    `${dashboardPath(dashboardId)}/widgets`,
+    data
   );
 }
-async function getCurrentProject() {
-  return makeRequest("GET", "/api/v1/me/project");
-}
-async function createProject(data) {
-  return makeRequest("POST", "/api/v1/projects", data);
+async function getWidgetOnDashboard({
+  dashboardId,
+  widgetId
+}) {
+  return makeRequest("GET", widgetPath(dashboardId, widgetId));
 }
-async function updateProject(params) {
-  const { id, ...data } = params;
+async function updateWidgetOnDashboard({
+  dashboardId,
+  widgetId,
+  ...changes
+}) {
   return makeRequest(
     "PATCH",
-    `/api/v1/projects/${encodeURIComponent(id)}`,
-    data
+    widgetPath(dashboardId, widgetId),
+    changes
   );
 }
-async function archiveProject(id) {
-  return makeRequest("DELETE", `/api/v1/projects/${encodeURIComponent(id)}`);
+async function deleteWidgetOnDashboard({
+  dashboardId,
+  widgetId
+}) {
+  await makeRequest("DELETE", widgetPath(dashboardId, widgetId));
 }
-var init_langwatch_api_projects = __esm({
-  "src/langwatch-api-projects.ts"() {
+var dashboardPath, widgetPath;
+var init_langwatch_api_dashboards = __esm({
+  "src/langwatch-api-dashboards.ts"() {
     "use strict";
     init_langwatch_api();
+    dashboardPath = (dashboardId) => `/api/v1/dashboards/${encodeURIComponent(dashboardId)}`;
+    widgetPath = (dashboardId, widgetId) => `${dashboardPath(dashboardId)}/widgets/${encodeURIComponent(widgetId)}`;
   }
 });
 
-// src/tools/list-dashboard-boards.ts
-var list_dashboard_boards_exports = {};
-__export(list_dashboard_boards_exports, {
-  handleListDashboardBoards: () => handleListDashboardBoards
+// src/tools/list-dashboards.ts
+var list_dashboards_exports = {};
+__export(list_dashboards_exports, {
+  handleListDashboards: () => handleListDashboards
 });
-async function handleListDashboardBoards() {
-  const project = await getCurrentProject();
-  const { data: boards } = await listBoards({ projectId: project.id });
-  if (boards.length === 0) {
+async function handleListDashboards() {
+  const { data: dashboards } = await listDashboards();
+  if (dashboards.length === 0) {
     return "No dashboards found in this project. Create one in the Dashboards area first.";
   }
   return [
-    `# Dashboards (${boards.length} total)
+    `# Dashboards (${dashboards.length} total)
 `,
-    ...boards.flatMap((board) => [
-      `## ${board.name}`,
-      `**ID**: ${board.id}`,
-      `**Widgets**: ${board.widgetCount}`,
-      `**URL**: ${board.platformUrl}`,
+    ...dashboards.flatMap((dashboard) => [
+      `## ${dashboard.name}`,
+      `**ID**: ${dashboard.id}`,
+      `**Widgets**: ${dashboard.widgetCount}`,
+      `**URL**: ${dashboard.platformUrl}`,
       ""
     ]),
     "> Pass the ID to `add_dashboard_widget` to add a widget to that dashboard."
   ].join("\n");
 }
-var init_list_dashboard_boards = __esm({
-  "src/tools/list-dashboard-boards.ts"() {
-    "use strict";
-    init_langwatch_api_boards();
-    init_langwatch_api_projects();
-  }
-});
-
-// src/langwatch-api-dashboard-widgets.ts
-async function createDashboardWidget(params) {
-  const { projectId: projectId2, ...data } = params;
-  return makeRequest(
-    "POST",
-    `/api/v1/projects/${encodeURIComponent(projectId2)}/analytics/dashboard-widgets`,
-    data
-  );
-}
-async function getDashboardWidget(params) {
-  return makeRequest(
-    "GET",
-    `/api/v1/projects/${encodeURIComponent(params.projectId)}/analytics/dashboard-widgets/${encodeURIComponent(params.widgetId)}`
-  );
-}
-async function updateDashboardWidget(params) {
-  const { projectId: projectId2, widgetId, ...data } = params;
-  return makeRequest(
-    "PATCH",
-    `/api/v1/projects/${encodeURIComponent(projectId2)}/analytics/dashboard-widgets/${encodeURIComponent(widgetId)}`,
-    data
-  );
-}
-async function assignDashboardWidgetToDashboard(params) {
-  return makeRequest(
-    "POST",
-    `/api/v1/projects/${encodeURIComponent(params.projectId)}/analytics/dashboard-widgets/${encodeURIComponent(params.widgetId)}/dashboard`,
-    { dashboardId: params.dashboardId }
-  );
-}
-async function deleteDashboardWidget(params) {
-  await makeRequest(
-    "DELETE",
-    `/api/v1/projects/${encodeURIComponent(params.projectId)}/analytics/dashboard-widgets/${encodeURIComponent(params.widgetId)}`
-  );
-}
-var init_langwatch_api_dashboard_widgets = __esm({
-  "src/langwatch-api-dashboard-widgets.ts"() {
+var init_list_dashboards = __esm({
+  "src/tools/list-dashboards.ts"() {
     "use strict";
-    init_langwatch_api();
+    init_langwatch_api_dashboards();
   }
 });
 
-// src/tools/dashboard-exists.ts
-async function assertDashboardExists({
-  projectId: projectId2,
-  dashboardId
+// src/tools/dashboard-widget-queries.ts
+function withSources({
+  queries,
+  sources
 }) {
-  try {
-    await getBoard({ projectId: projectId2, boardId: dashboardId });
-  } catch (error) {
-    if (error instanceof LangWatchApiError && error.status === 404) {
-      throw new Error(
-        `No dashboard with ID "${dashboardId}" was found in this project. Use list_dashboard_boards to find a valid dashboard ID.`
-      );
-    }
-    throw error;
-  }
+  if (sources === void 0) return [...queries];
+  return queries.map((query) => ({ ...query, sources }));
 }
-var init_dashboard_exists = __esm({
-  "src/tools/dashboard-exists.ts"() {
-    "use strict";
-    init_langwatch_api_boards();
-    init_langwatch_api();
-  }
-});
-
-// src/tools/dashboard-widget-queries.ts
 function normalizeDashboardWidgetQueries({
   queries
 }) {
@@ -5582,27 +5562,24 @@ __export(add_dashboard_widget_exports, {
   handleAddDashboardWidget: () => handleAddDashboardWidget
 });
 async function handleAddDashboardWidget(params) {
-  const queries = normalizeDashboardWidgetQueries({ queries: params.queries });
-  const project = await getCurrentProject();
-  await assertDashboardExists({ projectId: project.id, dashboardId: params.dashboardId });
-  const widget = await createDashboardWidget({
-    projectId: project.id,
-    name: params.name,
-    code: params.code,
-    queries
+  const queries = withSources({
+    queries: normalizeDashboardWidgetQueries({ queries: params.queries }),
+    sources: params.sources
   });
+  let widget;
   try {
-    await assignDashboardWidgetToDashboard({
-      projectId: project.id,
-      widgetId: widget.id,
-      dashboardId: params.dashboardId
+    widget = await createWidgetOnDashboard({
+      dashboardId: params.dashboardId,
+      name: params.name,
+      code: params.code,
+      queries
     });
   } catch (error) {
-    await deleteDashboardWidget({
-      projectId: project.id,
-      widgetId: widget.id
-    }).catch(() => {
-    });
+    if (error instanceof LangWatchApiError && error.status === 404) {
+      throw new Error(
+        `No dashboard with ID "${params.dashboardId}" was found in this project. Use list_dashboards to find a valid dashboard ID.`
+      );
+    }
     throw error;
   }
   return [
@@ -5614,9 +5591,8 @@ async function handleAddDashboardWidget(params) {
 var init_add_dashboard_widget = __esm({
   "src/tools/add-dashboard-widget.ts"() {
     "use strict";
-    init_langwatch_api_dashboard_widgets();
-    init_langwatch_api_projects();
-    init_dashboard_exists();
+    init_langwatch_api_dashboards();
+    init_langwatch_api();
     init_dashboard_widget_queries();
   }
 });
@@ -5627,22 +5603,24 @@ __export(update_dashboard_widget_exports, {
   handleUpdateDashboardWidget: () => handleUpdateDashboardWidget
 });
 async function handleUpdateDashboardWidget(params) {
-  const { dashboardId, widgetId, name, code, description } = params;
-  if (name === void 0 && code === void 0 && params.queries === void 0 && description === void 0) {
-    throw new Error("Provide at least one of name, code, queries or description to change.");
-  }
-  const queries = params.queries === void 0 ? void 0 : normalizeDashboardWidgetQueries({ queries: params.queries });
-  const project = await getCurrentProject();
-  await assertDashboardExists({ projectId: project.id, dashboardId });
-  const current = await getWidgetOnDashboard({ projectId: project.id, widgetId, dashboardId });
-  const widget = await updateDashboardWidget({
-    projectId: project.id,
-    widgetId: current.id,
+  const { dashboardId, widgetId, name, code, description, sources } = params;
+  const fields = [name, code, params.queries, description, sources];
+  if (fields.every((field) => field === void 0)) {
+    throw new Error(
+      "Provide at least one of name, code, queries, description or sources to change."
+    );
+  }
+  const current = await widgetOnDashboardOrRefused({ widgetId, dashboardId });
+  const given = params.queries === void 0 ? void 0 : normalizeDashboardWidgetQueries({ queries: params.queries });
+  const base = given ?? (sources === void 0 ? void 0 : current.definition.queries);
+  const queries = base === void 0 ? void 0 : withSources({ queries: base, sources });
+  const changes = {
     ...name === void 0 ? {} : { name },
     ...code === void 0 ? {} : { code },
     ...queries === void 0 ? {} : { queries },
     ...description === void 0 ? {} : { description }
-  });
+  };
+  const widget = await updateWidgetOnDashboard({ dashboardId, widgetId: current.id, ...changes });
   return [
     `Widget "${widget.name}" updated on dashboard "${dashboardId}".`,
     `**Widget ID**: ${widget.id}`,
@@ -5653,40 +5631,116 @@ async function handleUpdateDashboardWidget(params) {
     "```"
   ].join("\n");
 }
-async function getWidgetOnDashboard({
-  projectId: projectId2,
+async function widgetOnDashboardOrRefused({
   widgetId,
   dashboardId
 }) {
-  let widget;
   try {
-    widget = await getDashboardWidget({ projectId: projectId2, widgetId });
+    return await getWidgetOnDashboard({ dashboardId, widgetId });
   } catch (error) {
     if (error instanceof LangWatchApiError && error.status === 404) {
       throw new Error(
-        `No widget with ID "${widgetId}" was found in this project. Use the widget ID add_dashboard_widget returned.`
+        `No widget with ID "${widgetId}" was found on dashboard "${dashboardId}". Use the widget ID add_dashboard_widget returned, and the dashboard it was added to.`
       );
     }
     throw error;
   }
-  if (widget.dashboardId !== dashboardId) {
-    throw new Error(
-      `Widget "${widgetId}" is not on dashboard "${dashboardId}". Pass the dashboard the widget was added to.`
-    );
-  }
-  return widget;
 }
 var init_update_dashboard_widget = __esm({
   "src/tools/update-dashboard-widget.ts"() {
     "use strict";
-    init_langwatch_api_dashboard_widgets();
-    init_langwatch_api_projects();
+    init_langwatch_api_dashboards();
     init_langwatch_api();
-    init_dashboard_exists();
     init_dashboard_widget_queries();
   }
 });
 
+// src/tools/dashboards.ts
+var dashboards_exports = {};
+__export(dashboards_exports, {
+  handleCreateDashboard: () => handleCreateDashboard,
+  handleDeleteDashboard: () => handleDeleteDashboard,
+  handleDeleteDashboardWidget: () => handleDeleteDashboardWidget,
+  handleGetDashboard: () => handleGetDashboard,
+  handleListDashboardWidgets: () => handleListDashboardWidgets,
+  handleRenameDashboard: () => handleRenameDashboard
+});
+function describeDashboard(dashboard) {
+  return [
+    `**Name**: ${dashboard.name}`,
+    `**ID**: ${dashboard.id}`,
+    `**Scope**: ${dashboard.scope}`,
+    ...dashboard.description ? [`**Description**: ${dashboard.description}`] : [],
+    `**URL**: ${dashboard.platformUrl}`
+  ];
+}
+async function handleGetDashboard({
+  dashboardId
+}) {
+  const dashboard = await getDashboard({ dashboardId });
+  return [`# ${dashboard.name}
+`, ...describeDashboard(dashboard)].join("\n");
+}
+async function handleCreateDashboard({ name }) {
+  const dashboard = await createDashboard({ name });
+  return [
+    "Dashboard created.\n",
+    ...describeDashboard(dashboard),
+    "",
+    "> Pass the ID to `add_dashboard_widget` to add a widget to it."
+  ].join("\n");
+}
+async function handleRenameDashboard({
+  dashboardId,
+  name,
+  description
+}) {
+  if (name === void 0 && description === void 0) {
+    throw new Error("Provide at least one of name or description to change.");
+  }
+  const dashboard = await updateDashboard({
+    dashboardId,
+    ...name === void 0 ? {} : { name },
+    ...description === void 0 ? {} : { description }
+  });
+  return ["Dashboard updated.\n", ...describeDashboard(dashboard)].join("\n");
+}
+async function handleDeleteDashboard({
+  dashboardId
+}) {
+  const deleted = await deleteDashboard({ dashboardId });
+  return `Dashboard "${deleted.name}" deleted with its widgets (ID: ${deleted.id}).`;
+}
+async function handleListDashboardWidgets({
+  dashboardId
+}) {
+  const { data: widgets } = await listWidgetsOnDashboard({ dashboardId });
+  if (widgets.length === 0) return `Dashboard "${dashboardId}" has no widgets.`;
+  return [
+    `# Widgets on dashboard ${dashboardId} (${widgets.length} total)
+`,
+    ...widgets.flatMap((widget) => [
+      `## ${widget.name}`,
+      `**ID**: ${widget.id}`,
+      `**Queries**: ${widget.definition.queries.map((query) => query.name).join(", ") || "(none)"}`,
+      ""
+    ])
+  ].join("\n");
+}
+async function handleDeleteDashboardWidget({
+  dashboardId,
+  widgetId
+}) {
+  await deleteWidgetOnDashboard({ dashboardId, widgetId });
+  return `Widget "${widgetId}" deleted from dashboard "${dashboardId}".`;
+}
+var init_dashboards = __esm({
+  "src/tools/dashboards.ts"() {
+    "use strict";
+    init_langwatch_api_dashboards();
+  }
+});
+
 // src/tools/list-workflows.ts
 var list_workflows_exports = {};
 __export(list_workflows_exports, {
@@ -5938,7 +5992,7 @@ __export(langwatch_api_triggers_exports, {
   updateTrigger: () => updateTrigger
 });
 async function listTriggers() {
-  return import_zod7.z.array(triggerSchema).parse(await makeRequest("GET", "/api/v1/triggers"));
+  return import_zod8.z.array(triggerSchema).parse(await makeRequest("GET", "/api/v1/triggers"));
 }
 async function getTrigger(id) {
   return triggerSchema.parse(
@@ -5981,11 +6035,11 @@ async function deleteTrigger(id) {
     await makeRequest("DELETE", `/api/v1/triggers/${encodeURIComponent(id)}`)
   );
 }
-var import_zod7;
+var import_zod8;
 var init_langwatch_api_triggers = __esm({
   "src/langwatch-api-triggers.ts"() {
     "use strict";
-    import_zod7 = require("zod");
+    import_zod8 = require("zod");
     init_langwatch_api();
     init_triggers();
   }
@@ -6620,6 +6674,41 @@ 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/v1/projects${qs}`);
+}
+async function getProject(id) {
+  return makeRequest(
+    "GET",
+    `/api/v1/projects/${encodeURIComponent(id)}`
+  );
+}
+async function createProject(data) {
+  return makeRequest("POST", "/api/v1/projects", data);
+}
+async function updateProject(params) {
+  const { id, ...data } = params;
+  return makeRequest(
+    "PATCH",
+    `/api/v1/projects/${encodeURIComponent(id)}`,
+    data
+  );
+}
+async function archiveProject(id) {
+  return makeRequest("DELETE", `/api/v1/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, {
@@ -6886,7 +6975,7 @@ __export(create_mcp_server_exports, {
 });
 module.exports = __toCommonJS(create_mcp_server_exports);
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 init_package();
 init_config();
 
@@ -7008,6 +7097,25 @@ init_run_plan();
 init_suite_fields();
 init_triggers();
 
+// src/schemas/widget-sources.ts
+var import_zod5 = require("zod");
+var WIDGET_SOURCES = [
+  "application",
+  "simulation",
+  "evaluation",
+  "sample",
+  "coding_agent",
+  "ai_tool",
+  "gateway",
+  "workflow",
+  "playground",
+  "langy",
+  "other"
+];
+var widgetSourcesInput = import_zod5.z.array(import_zod5.z.enum(WIDGET_SOURCES)).max(WIDGET_SOURCES.length).nullable().optional().describe(
+  `The trace origins every query of the widget counts: any of ${WIDGET_SOURCES.join(", ")} (other = any origin not listed). A new widget counts ["application"]; add "langy" to count your own conversations, as a widget about Langy's requests needs. null makes it unset again, counting the default.`
+);
+
 // src/tools/get-experiment-results.ts
 init_langwatch_api();
 
@@ -7393,7 +7501,8 @@ init_langwatch_api();
 async function handleRunExperiment(params) {
   const result = await makeRequest(
     "POST",
-    `/api/v1/experiments/${encodeURIComponent(params.slug)}/run`
+    `/api/v1/experiments/${encodeURIComponent(params.slug)}/run`,
+    params.concurrency !== void 0 ? { concurrency: params.concurrency } : void 0
   );
   const lines = [];
   lines.push(`Evaluation started!
@@ -7548,8 +7657,8 @@ async function handleUpdateTestSuite(params) {
 }
 
 // src/create-mcp-server.ts
-var modelSchema = import_zod8.z.string().describe(
-  'Model in "provider/model-name" format, e.g., "openai/gpt-4o", "anthropic/claude-sonnet-4-5-20250929"'
+var modelSchema = import_zod9.z.string().describe(
+  'Model in "provider/model-name" format, e.g., "openai/gpt-6-luna", "anthropic/claude-sonnet-4-5-20250929"'
 );
 function createMcpServer() {
   const server = new import_mcp.McpServer({
@@ -7584,6 +7693,7 @@ function registerTools(server) {
   registerEvaluatorTools(server);
   registerModelProviderTools(server);
   registerAgentTools(server);
+  registerAnalyticsReportTools(server);
   registerDashboardTools(server);
   registerWorkflowTools(server);
   registerAnnotationTools(server);
@@ -7600,7 +7710,7 @@ function registerDocsTools(server) {
     "fetch_langwatch_docs",
     "Fetches the LangWatch docs for understanding how to implement LangWatch in your codebase. Always use this tool when the user asks for help with LangWatch. Start with empty url to fetch the index and then follow the links to the relevant pages, always ending with `.md` extension",
     {
-      url: import_zod8.z.string().optional().describe(
+      url: import_zod9.z.string().optional().describe(
         "The full url of the specific doc page. If not provided, the docs index will be fetched."
       )
     },
@@ -7613,18 +7723,18 @@ function registerDocsTools(server) {
     "report_issue",
     "Report an issue to the LangWatch team: anything that did not work, confused you, or took trial and error while using LangWatch (docs, MCP tools, CLI, SDKs, the platform). Use it whenever you struggled, it is how rough edges get fixed for every agent. Ask the user for permission first, then call with user_approved=true. Works without an API key. Put VERBATIM error messages in the summary; optionally attach raw session content. Secrets, API keys, emails and phone numbers are redacted locally before anything is sent.",
     {
-      user_approved: import_zod8.z.boolean().describe(
+      user_approved: import_zod9.z.boolean().describe(
         "Must be true, and only after the user explicitly agreed to send this report to LangWatch"
       ),
-      title: import_zod8.z.string().max(300).describe("One-line description of the issue"),
-      summary: import_zod8.z.string().optional().describe(
+      title: import_zod9.z.string().max(300).describe("One-line description of the issue"),
+      summary: import_zod9.z.string().optional().describe(
         "What you were trying to do, what went wrong (verbatim errors), and what you had to figure out the hard way"
       ),
-      session_content: import_zod8.z.string().optional().describe(
+      session_content: import_zod9.z.string().optional().describe(
         "Optional raw session transcript or log excerpt (JSONL or plain text); redacted locally before sending"
       ),
-      contact_email: import_zod8.z.string().optional().describe("Optional contact email for follow-up"),
-      agent: import_zod8.z.string().optional().describe("Which coding agent this is, e.g. claude-code, codex, cursor")
+      contact_email: import_zod9.z.string().optional().describe("Optional contact email for follow-up"),
+      agent: import_zod9.z.string().optional().describe("Which coding agent this is, e.g. claude-code, codex, cursor")
     },
     withToolLogging("report_issue", async (params) => {
       const { handleReportIssue: handleReportIssue2 } = await Promise.resolve().then(() => (init_report_issue(), report_issue_exports));
@@ -7637,7 +7747,7 @@ function registerDocsTools(server) {
     "fetch_scenario_docs",
     "Fetches the Scenario docs for understanding how to implement Scenario agent tests in your codebase. Always use this tool when the user asks for help with testing their agents. Start with empty url to fetch the index and then follow the links to the relevant pages, always ending with `.md` extension",
     {
-      url: import_zod8.z.string().optional().describe(
+      url: import_zod9.z.string().optional().describe(
         "The full url of the specific doc page. If not provided, the docs index will be fetched."
       )
     },
@@ -7652,7 +7762,7 @@ function registerObservabilityTools(server) {
     "discover_schema",
     "Discover what LangWatch can be queried with: the trace filter fields and syntax, the analytics SQL views and columns, the analytics metrics, aggregation types, group-by options, scenario schema and evaluator types. Call this before using search_traces, run_query, get_analytics, scenario tools or evaluator tools, so you never guess a field, a column or a value.",
     {
-      category: import_zod8.z.enum([
+      category: import_zod9.z.enum([
         "filters",
         "lwql",
         "metrics",
@@ -7664,7 +7774,7 @@ function registerObservabilityTools(server) {
       ]).describe(
         "Which schema category to discover. 'filters' is the trace filter language, 'lwql' the analytics SQL views; both are read from the platform and need the API key"
       ),
-      evaluatorType: import_zod8.z.string().optional().describe(
+      evaluatorType: import_zod9.z.string().optional().describe(
         "When category is 'evaluators', provide a specific evaluator type (e.g. 'langevals/llm_boolean') to get its full schema details"
       )
     },
@@ -7697,10 +7807,10 @@ function registerObservabilityTools(server) {
     "run_query",
     "Run one read-only analytics SQL statement (LangWatchQL) over this project's traces, spans, evaluations and metrics, and get the rows back as a table. This is the tool for a count, a rate, a sum, a percentile or any of them grouped or over time \u2014 questions search_traces would need many calls to answer. The statement runs exactly as written. Call discover_schema with category 'lwql' first for the views, columns and worked statements.",
     {
-      sql: import_zod8.z.string().describe(
+      sql: import_zod9.z.string().describe(
         "The SELECT to run. Filter on the dataset's time column so the read is bounded, and never select a whole attribute map"
       ),
-      parameters: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number(), import_zod8.z.boolean(), import_zod8.z.null()])).optional().describe(
+      parameters: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number(), import_zod9.z.boolean(), import_zod9.z.null()])).optional().describe(
         'Values for the parameters the statement declares, e.g. {"days": 7} for {days:UInt32}'
       )
     },
@@ -7716,25 +7826,25 @@ function registerObservabilityTools(server) {
     "search_traces",
     "Search LangWatch traces by content, with filters and a date range. Returns AI-readable trace digests by default. Use format: 'json' for full raw data. To fetch a trace you already have the ID for, use get_trace instead \u2014 free text does not match trace IDs.",
     {
-      query: import_zod8.z.string().optional().describe(
+      query: import_zod9.z.string().optional().describe(
         "Text search query. Matches captured input/output, the trace name and span names ONLY. It does not match trace IDs \u2014 to fetch a known trace ID use get_trace, or pass traceIds here for several at once."
       ),
-      traceIds: import_zod8.z.array(import_zod8.z.string().min(1)).min(1).max(1e3).optional().describe(
+      traceIds: import_zod9.z.array(import_zod9.z.string().min(1)).min(1).max(1e3).optional().describe(
         "Exact trace IDs to fetch (1\u20131000). Use instead of query when you already know the IDs. When set and no startDate is given, the window defaults to the last 90 days rather than 24 hours."
       ),
-      filters: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.array(import_zod8.z.string())).optional().describe(
+      filters: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.array(import_zod9.z.string())).optional().describe(
         'Filter traces by the older per-field map. Format: {"field": ["value"]}. Use discover_schema for field names.'
       ),
-      filter: import_zod8.z.string().optional().describe(
+      filter: import_zod9.z.string().optional().describe(
         'Filter traces with the Trace Explorer\'s own query language: "status:error AND model:gpt-*", "trace.attribute.langwatch.user_id:alice", "evaluatorVerdict:fail", a quoted phrase for free text. Reaches attribute keys, span events and evaluator verdicts that the `filters` map cannot. Combined with `filters` and `query` when you send more than one. Call discover_schema with category \'filters\' for every field and the syntax.'
       ),
-      startDate: import_zod8.z.string().min(1).optional().describe(
+      startDate: import_zod9.z.string().min(1).optional().describe(
         'Start of the window: ISO date, or relative like "24h", "7d", "4w", "3m" \u2014 units are h (hours), d (days), w (weeks), m (30-day months). Defaults to 24h ago for a text search, or 90d when traceIds is set. Widen this when a search comes back empty.'
       ),
-      endDate: import_zod8.z.string().min(1).optional().describe("End of the window: ISO date or relative. Default: now"),
-      pageSize: import_zod8.z.number().optional().describe("Results per page (default: 25, max: 1000)"),
-      scrollId: import_zod8.z.string().optional().describe("Pagination token from previous search"),
-      format: import_zod8.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
+      endDate: import_zod9.z.string().min(1).optional().describe("End of the window: ISO date or relative. Default: now"),
+      pageSize: import_zod9.z.number().optional().describe("Results per page (default: 25, max: 1000)"),
+      scrollId: import_zod9.z.string().optional().describe("Pagination token from previous search"),
+      format: import_zod9.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
     },
     withToolLogging("search_traces", async (params) => {
       requireApiKey();
@@ -7748,10 +7858,10 @@ function registerObservabilityTools(server) {
     "get_trace",
     "Get full details of a single trace by ID. This is the right tool whenever you have a trace ID \u2014 search_traces does not match IDs. A full ID resolves at any age; a unique 8\u201331 character hex prefix resolves within the last 90 days. Returns AI-readable trace digest by default. Use format: 'json' for full raw data including all spans.",
     {
-      traceId: import_zod8.z.string().describe(
+      traceId: import_zod9.z.string().describe(
         "The trace ID to retrieve. A full ID resolves at any age; a unique 8\u201331 character hex prefix also resolves, git-style, within the last 90 days."
       ),
-      format: import_zod8.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
+      format: import_zod9.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
     },
     withToolLogging("get_trace", async (params) => {
       requireApiKey();
@@ -7765,17 +7875,17 @@ function registerObservabilityTools(server) {
     "get_analytics",
     'Query analytics timeseries from LangWatch. Metrics use "category.name" format (e.g., "performance.completion_time"). Use discover_schema to see available metrics.',
     {
-      metric: import_zod8.z.string().describe(
+      metric: import_zod9.z.string().describe(
         'Metric in "category.name" format, e.g., "metadata.trace_id", "performance.total_cost"'
       ),
-      aggregation: import_zod8.z.string().optional().describe(
+      aggregation: import_zod9.z.string().optional().describe(
         "Aggregation type: avg, sum, min, max, median, p90, p95, p99, cardinality, terms. Default: avg"
       ),
-      startDate: import_zod8.z.string().optional().describe('Start date: ISO or relative ("7d", "30d"). Default: 7 days ago'),
-      endDate: import_zod8.z.string().optional().describe("End date. Default: now"),
-      timeZone: import_zod8.z.string().optional().describe("Timezone. Default: UTC"),
-      groupBy: import_zod8.z.string().optional().describe("Group results by field. Use discover_schema for options."),
-      filters: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.array(import_zod8.z.string())).optional().describe("Filters to apply")
+      startDate: import_zod9.z.string().optional().describe('Start date: ISO or relative ("7d", "30d"). Default: 7 days ago'),
+      endDate: import_zod9.z.string().optional().describe("End date. Default: now"),
+      timeZone: import_zod9.z.string().optional().describe("Timezone. Default: UTC"),
+      groupBy: import_zod9.z.string().optional().describe("Group results by field. Use discover_schema for options."),
+      filters: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.array(import_zod9.z.string())).optional().describe("Filters to apply")
     },
     withToolLogging("get_analytics", async (params) => {
       requireApiKey();
@@ -7798,16 +7908,16 @@ NOTE: Prompts can be managed two ways. Determine which approach the user needs:
 2. Platform-based (LangWatch UI): If the user wants to manage prompts directly on the LangWatch platform, use the \`platform_\` MCP tools (\`platform_create_prompt\`, \`platform_update_prompt\`, etc.).
 `,
     {
-      name: import_zod8.z.string().describe("Prompt display name"),
-      handle: import_zod8.z.string().optional().describe("URL-friendly handle (auto-generated from name if omitted)"),
-      messages: import_zod8.z.array(
-        import_zod8.z.object({
-          role: import_zod8.z.enum(["system", "user", "assistant"]).describe("Message role"),
-          content: import_zod8.z.string().describe("Message content")
+      name: import_zod9.z.string().describe("Prompt display name"),
+      handle: import_zod9.z.string().optional().describe("URL-friendly handle (auto-generated from name if omitted)"),
+      messages: import_zod9.z.array(
+        import_zod9.z.object({
+          role: import_zod9.z.enum(["system", "user", "assistant"]).describe("Message role"),
+          content: import_zod9.z.string().describe("Message content")
         })
       ).describe("Prompt messages"),
       model: modelSchema,
-      tags: import_zod8.z.array(import_zod8.z.string()).optional().describe(
+      tags: import_zod9.z.array(import_zod9.z.string()).optional().describe(
         'Tags to assign to the initial version (e.g., ["production", "staging"]). Built-in tags: "latest" (auto-assigned), "production", "staging". Custom tags must be created first.'
       )
     },
@@ -7835,12 +7945,12 @@ NOTE: Prompts can be managed two ways. Determine which approach the user needs:
     "platform_get_prompt",
     "Get a specific prompt from the LangWatch platform by ID or handle, including messages, model config, and version history. Use format: 'json' for the full raw API payload, or 'digest' (default) for a formatted summary.",
     {
-      idOrHandle: import_zod8.z.string().describe("Prompt ID or handle"),
-      version: import_zod8.z.number().optional().describe("Specific version number (default: latest)"),
-      tag: import_zod8.z.string().optional().describe(
+      idOrHandle: import_zod9.z.string().describe("Prompt ID or handle"),
+      version: import_zod9.z.number().optional().describe("Specific version number (default: latest)"),
+      tag: import_zod9.z.string().optional().describe(
         'Fetch the version pointed to by this tag (e.g., "production", "staging"). Alternatively, use shorthand in idOrHandle: "pizza-prompt:production"'
       ),
-      format: import_zod8.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
+      format: import_zod9.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
     },
     withToolLogging("platform_get_prompt", async (params) => {
       if (params.version != null && params.tag) {
@@ -7860,16 +7970,16 @@ NOTE: Prompts can be managed two ways. Determine which approach the user needs:
     "platform_update_prompt",
     "Update an existing prompt on the LangWatch platform. Every update creates a new version.",
     {
-      idOrHandle: import_zod8.z.string().describe("Prompt ID or handle to update"),
-      messages: import_zod8.z.array(
-        import_zod8.z.object({
-          role: import_zod8.z.enum(["system", "user", "assistant"]),
-          content: import_zod8.z.string()
+      idOrHandle: import_zod9.z.string().describe("Prompt ID or handle to update"),
+      messages: import_zod9.z.array(
+        import_zod9.z.object({
+          role: import_zod9.z.enum(["system", "user", "assistant"]),
+          content: import_zod9.z.string()
         })
       ).optional().describe("Updated messages"),
       model: modelSchema.optional(),
-      commitMessage: import_zod8.z.string().describe("Commit message describing the change"),
-      tags: import_zod8.z.array(import_zod8.z.string()).optional().describe("Tags to assign to the new version created by this update.")
+      commitMessage: import_zod9.z.string().describe("Commit message describing the change"),
+      tags: import_zod9.z.array(import_zod9.z.string()).optional().describe("Tags to assign to the new version created by this update.")
     },
     withToolLogging("platform_update_prompt", async (params) => {
       requireApiKey();
@@ -7883,9 +7993,9 @@ NOTE: Prompts can be managed two ways. Determine which approach the user needs:
     "platform_assign_prompt_tag",
     'Assign a tag (e.g. "production") to a specific version of a prompt. Use this to "deploy" a version by promoting it to the production tag.',
     {
-      idOrHandle: import_zod8.z.string().describe("Prompt ID or handle"),
-      tag: import_zod8.z.string().describe('Tag name (e.g., "production", "staging")'),
-      versionId: import_zod8.z.string().describe("The version ID to assign the tag to")
+      idOrHandle: import_zod9.z.string().describe("Prompt ID or handle"),
+      tag: import_zod9.z.string().describe('Tag name (e.g., "production", "staging")'),
+      versionId: import_zod9.z.string().describe("The version ID to assign the tag to")
     },
     withToolLogging("platform_assign_prompt_tag", async (params) => {
       requireApiKey();
@@ -7911,7 +8021,7 @@ NOTE: Prompts can be managed two ways. Determine which approach the user needs:
     "platform_create_prompt_tag",
     'Create a custom prompt tag definition for the organization. Tag names must be non-numeric and not "latest".',
     {
-      name: import_zod8.z.string().describe("Tag name to create")
+      name: import_zod9.z.string().describe("Tag name to create")
     },
     withToolLogging("platform_create_prompt_tag", async (params) => {
       requireApiKey();
@@ -7925,8 +8035,8 @@ NOTE: Prompts can be managed two ways. Determine which approach the user needs:
     "platform_rename_prompt_tag",
     'Rename an existing prompt tag. The "latest" tag cannot be renamed.',
     {
-      tag: import_zod8.z.string().describe("Current tag name to rename"),
-      name: import_zod8.z.string().describe("New tag name")
+      tag: import_zod9.z.string().describe("Current tag name to rename"),
+      name: import_zod9.z.string().describe("New tag name")
     },
     withToolLogging("platform_rename_prompt_tag", async (params) => {
       requireApiKey();
@@ -7940,7 +8050,7 @@ NOTE: Prompts can be managed two ways. Determine which approach the user needs:
     "platform_delete_prompt_tag",
     'Delete a prompt tag and all its assignments. The "latest" tag cannot be deleted.',
     {
-      tag: import_zod8.z.string().describe("Tag name to delete")
+      tag: import_zod9.z.string().describe("Tag name to delete")
     },
     withToolLogging("platform_delete_prompt_tag", async (params) => {
       requireApiKey();
@@ -7963,11 +8073,11 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
 2. Platform-based (LangWatch UI): If the user wants to manage scenarios directly on the LangWatch platform, use the \`platform_\` MCP tools (\`platform_create_scenario\`, \`platform_update_scenario\`, etc.).
 `,
     {
-      name: import_zod8.z.string().describe("Scenario name"),
-      situation: import_zod8.z.string().describe("The context or setup describing what the user/agent is doing"),
-      criteria: import_zod8.z.array(import_zod8.z.string()).optional().describe("Pass/fail conditions the agent's response must satisfy"),
-      labels: import_zod8.z.array(import_zod8.z.string()).optional().describe("Tags for organizing and filtering scenarios"),
-      testSuiteId: import_zod8.z.string().nullish().describe(
+      name: import_zod9.z.string().describe("Scenario name"),
+      situation: import_zod9.z.string().describe("The context or setup describing what the user/agent is doing"),
+      criteria: import_zod9.z.array(import_zod9.z.string()).optional().describe("Pass/fail conditions the agent's response must satisfy"),
+      labels: import_zod9.z.array(import_zod9.z.string()).optional().describe("Tags for organizing and filtering scenarios"),
+      testSuiteId: import_zod9.z.string().nullish().describe(
         "The test suite to file this scenario in. Pass a test suite ID, or null to unfile it."
       ),
       fields: scenarioFieldValuesSchema.optional()
@@ -7984,8 +8094,8 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     "platform_list_scenarios",
     "List all scenarios on the LangWatch platform. Returns AI-readable digest by default.",
     {
-      testSuiteId: import_zod8.z.string().optional().describe("Only the scenarios filed in this test suite"),
-      format: import_zod8.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
+      testSuiteId: import_zod9.z.string().optional().describe("Only the scenarios filed in this test suite"),
+      format: import_zod9.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
     },
     withToolLogging("platform_list_scenarios", async (params) => {
       requireApiKey();
@@ -7999,8 +8109,8 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     "platform_get_scenario",
     "Get full details of a scenario on the LangWatch platform by ID, including situation, criteria, and labels.",
     {
-      scenarioId: import_zod8.z.string().describe("The scenario ID to retrieve"),
-      format: import_zod8.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
+      scenarioId: import_zod9.z.string().describe("The scenario ID to retrieve"),
+      format: import_zod9.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
     },
     withToolLogging("platform_get_scenario", async (params) => {
       requireApiKey();
@@ -8014,12 +8124,12 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     "platform_update_scenario",
     "Update an existing scenario on the LangWatch platform.",
     {
-      scenarioId: import_zod8.z.string().describe("The scenario ID to update"),
-      name: import_zod8.z.string().optional().describe("Updated scenario name"),
-      situation: import_zod8.z.string().optional().describe("Updated situation"),
-      criteria: import_zod8.z.array(import_zod8.z.string()).optional().describe("Updated criteria"),
-      labels: import_zod8.z.array(import_zod8.z.string()).optional().describe("Updated labels"),
-      testSuiteId: import_zod8.z.string().nullish().describe(
+      scenarioId: import_zod9.z.string().describe("The scenario ID to update"),
+      name: import_zod9.z.string().optional().describe("Updated scenario name"),
+      situation: import_zod9.z.string().optional().describe("Updated situation"),
+      criteria: import_zod9.z.array(import_zod9.z.string()).optional().describe("Updated criteria"),
+      labels: import_zod9.z.array(import_zod9.z.string()).optional().describe("Updated labels"),
+      testSuiteId: import_zod9.z.string().nullish().describe(
         "The test suite to file this scenario in. Pass a test suite ID, or null to unfile it."
       ),
       fields: scenarioFieldValuesSchema.optional()
@@ -8036,7 +8146,7 @@ NOTE: Scenarios can be created two ways. Determine which approach the user needs
     "platform_archive_scenario",
     "Archive (soft-delete) a scenario on the LangWatch platform.",
     {
-      scenarioId: import_zod8.z.string().describe("The scenario ID to archive")
+      scenarioId: import_zod9.z.string().describe("The scenario ID to archive")
     },
     withToolLogging("platform_archive_scenario", async (params) => {
       requireApiKey();
@@ -8052,27 +8162,27 @@ function registerRunPlanTools(server) {
     "platform_run_plan",
     "Run scenarios against targets. The plan name identifies the run plan: an existing name is re-run with the configuration you send here, a new name creates the plan. Configuration is the scope, the targets, the repeat count and the models; parameters, the note and the idempotency key belong to this run alone. Send more than one target to compare them in the same run, and give a target its own parameters to compare one agent on two models.",
     {
-      name: import_zod8.z.string().optional().describe(
+      name: import_zod9.z.string().optional().describe(
         "The run plan to run. An existing name is replaced with this configuration, a new name creates the plan. Omit to let the server name it after the suite and the target."
       ),
       scope: runPlanScopeSchema.describe(
         "What the plan covers: every scenario in the project, the scenarios filed in given test suites, the scenarios carrying given labels, or the hand-picked list in scenarioIds."
       ),
-      scenarioIds: import_zod8.z.array(import_zod8.z.string()).optional().describe("The scenarios to run. Read only when scope.mode is 'scenarios'."),
-      targets: import_zod8.z.array(runPlanTargetSchema).describe(
+      scenarioIds: import_zod9.z.array(import_zod9.z.string()).optional().describe("The scenarios to run. Read only when scope.mode is 'scenarios'."),
+      targets: import_zod9.z.array(runPlanTargetSchema).describe(
         "What to run the scenarios against. Every target runs every scenario, and the results show one column for each, so this is how one run compares two agents or one agent on two models."
       ),
-      repeatCount: import_zod8.z.number().int().min(1).max(5).optional().describe("How many times to run each scenario against each target (1 to 5, default 1)"),
-      simulatorModel: import_zod8.z.string().optional().describe("Model that plays the user. Omit for the project default."),
-      judgeModel: import_zod8.z.string().optional().describe("Model that judges the criteria. Omit for the project default."),
+      repeatCount: import_zod9.z.number().int().min(1).max(5).optional().describe("How many times to run each scenario against each target (1 to 5, default 1)"),
+      simulatorModel: import_zod9.z.string().optional().describe("Model that plays the user. Omit for the project default."),
+      judgeModel: import_zod9.z.string().optional().describe("Model that judges the criteria. Omit for the project default."),
       evaluators: evaluatorAttachmentsSchema.optional().describe(
         "The plan's own evaluators, run beside the ones attached to the test suites its scenarios belong to. A plan evaluator reads the conversation and the trace, never a scenario field. Omit to keep what the plan already holds. See discover_schema({ category: 'scenarios' }) for the mapping paths."
       ),
       parameters: runParametersSchema.optional().describe(
         "Values for the parameters the scenarios declare, by name. They apply to every target; a target that names the same parameter overrides them for itself."
       ),
-      note: import_zod8.z.string().max(200).optional().describe("One short line saying why this run was started (max 200 characters)"),
-      idempotencyKey: import_zod8.z.string().optional().describe(
+      note: import_zod9.z.string().max(200).optional().describe("One short line saying why this run was started (max 200 characters)"),
+      idempotencyKey: import_zod9.z.string().optional().describe(
         "Send the same key to make a retry join the run it already started instead of starting a second one."
       )
     },
@@ -8088,8 +8198,8 @@ function registerRunPlanTools(server) {
     "platform_list_run_plans",
     "List the run plans of the project. A run plan holds the configuration a run used, keyed by its name.",
     {
-      includeArchived: import_zod8.z.boolean().optional().describe("Include archived plans (default false)"),
-      format: import_zod8.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default) or 'json' (raw data)")
+      includeArchived: import_zod9.z.boolean().optional().describe("Include archived plans (default false)"),
+      format: import_zod9.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default) or 'json' (raw data)")
     },
     withToolLogging("platform_list_run_plans", async (params) => {
       requireApiKey();
@@ -8103,8 +8213,8 @@ function registerRunPlanTools(server) {
     "platform_get_run_plan",
     "Get the full configuration of a run plan: what it covers, its targets, its repeat count and its models.",
     {
-      id: import_zod8.z.string().describe("The run plan ID"),
-      format: import_zod8.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default) or 'json'")
+      id: import_zod9.z.string().describe("The run plan ID"),
+      format: import_zod9.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default) or 'json'")
     },
     withToolLogging("platform_get_run_plan", async (params) => {
       requireApiKey();
@@ -8118,9 +8228,9 @@ function registerRunPlanTools(server) {
     "platform_rerun_run_plan",
     "Run a plan again with the configuration it already holds. Only the parameters and the note belong to the new run.",
     {
-      id: import_zod8.z.string().describe("The run plan ID to run again"),
+      id: import_zod9.z.string().describe("The run plan ID to run again"),
       parameters: runParametersSchema.optional().describe("Values for the parameters the scenarios declare, by name."),
-      note: import_zod8.z.string().max(200).optional().describe("One short line saying why this run was started (max 200 characters)")
+      note: import_zod9.z.string().max(200).optional().describe("One short line saying why this run was started (max 200 characters)")
     },
     withToolLogging("platform_rerun_run_plan", async (params) => {
       requireApiKey();
@@ -8134,7 +8244,7 @@ function registerRunPlanTools(server) {
     "platform_archive_run_plan",
     "Archive a run plan. Its past runs stay readable and the name is free for a new plan.",
     {
-      id: import_zod8.z.string().describe("The run plan ID to archive")
+      id: import_zod9.z.string().describe("The run plan ID to archive")
     },
     withToolLogging("platform_archive_run_plan", async (params) => {
       requireApiKey();
@@ -8150,7 +8260,7 @@ function registerTestSuiteTools(server) {
     "platform_list_test_suites",
     "List the test suites of the project. A test suite groups scenarios.",
     {
-      format: import_zod8.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default) or 'json' (raw data)")
+      format: import_zod9.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default) or 'json' (raw data)")
     },
     withToolLogging("platform_list_test_suites", async (params) => {
       requireApiKey();
@@ -8164,7 +8274,7 @@ function registerTestSuiteTools(server) {
     "platform_create_test_suite",
     "Create a test suite. A test suite groups scenarios: file a scenario in it by passing the suite ID as testSuiteId on platform_create_scenario or platform_update_scenario. A suite can declare typed fields every scenario carries a value for, and attach saved evaluators that run after every scenario run with mappings from their inputs to the conversation, the scenario's fields or the trace. Call discover_schema({ category: 'scenarios' }) first for the field rules and the mapping paths.",
     {
-      name: import_zod8.z.string().describe("Test suite name"),
+      name: import_zod9.z.string().describe("Test suite name"),
       fields: suiteFieldsSchema.optional(),
       evaluators: evaluatorAttachmentsSchema.optional()
     },
@@ -8180,8 +8290,8 @@ function registerTestSuiteTools(server) {
     "platform_get_test_suite",
     "Get a test suite and the scenarios filed in it.",
     {
-      id: import_zod8.z.string().describe("The test suite ID"),
-      format: import_zod8.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default) or 'json'")
+      id: import_zod9.z.string().describe("The test suite ID"),
+      format: import_zod9.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default) or 'json'")
     },
     withToolLogging("platform_get_test_suite", async (params) => {
       requireApiKey();
@@ -8195,8 +8305,8 @@ function registerTestSuiteTools(server) {
     "platform_update_test_suite",
     "Edit a test suite: any of its name, its fields and its evaluators. A field list or an evaluator list replaces the one the suite holds; a key left out keeps what the suite has. A field an attached evaluator still reads cannot be removed. Call discover_schema({ category: 'scenarios' }) first for the field rules and the mapping paths.",
     {
-      id: import_zod8.z.string().describe("The test suite ID"),
-      name: import_zod8.z.string().optional().describe("The new name. The slug is kept."),
+      id: import_zod9.z.string().describe("The test suite ID"),
+      name: import_zod9.z.string().optional().describe("The new name. The slug is kept."),
       fields: suiteFieldsSchema.optional().describe(
         "The full list of fields the suite declares. It replaces the list the suite holds."
       ),
@@ -8215,8 +8325,8 @@ function registerTestSuiteTools(server) {
     "platform_rename_test_suite",
     "Rename a test suite.",
     {
-      id: import_zod8.z.string().describe("The test suite ID"),
-      name: import_zod8.z.string().describe("The new name")
+      id: import_zod9.z.string().describe("The test suite ID"),
+      name: import_zod9.z.string().describe("The new name")
     },
     withToolLogging("platform_rename_test_suite", async (params) => {
       requireApiKey();
@@ -8230,7 +8340,7 @@ function registerTestSuiteTools(server) {
     "platform_archive_test_suite",
     "Archive a test suite. The scenarios filed in it are archived with it.",
     {
-      id: import_zod8.z.string().describe("The test suite ID to archive")
+      id: import_zod9.z.string().describe("The test suite ID to archive")
     },
     withToolLogging("platform_archive_test_suite", async (params) => {
       requireApiKey();
@@ -8244,20 +8354,20 @@ function registerTestSuiteTools(server) {
     "platform_run_test_suite",
     "Run every scenario of a test suite against targets. This creates or joins the run plan named '<suite name> <target name>' unless you send a name of your own. Send more than one target to compare them in the same run, and give a target its own parameters to compare one agent on two models.",
     {
-      id: import_zod8.z.string().describe("The test suite ID to run"),
-      targets: import_zod8.z.array(runPlanTargetSchema).describe(
+      id: import_zod9.z.string().describe("The test suite ID to run"),
+      targets: import_zod9.z.array(runPlanTargetSchema).describe(
         "What to run the scenarios against. Every target runs every scenario, and the results show one column for each."
       ),
-      name: import_zod8.z.string().optional().describe(
+      name: import_zod9.z.string().optional().describe(
         "The run plan to run. Omit to let the server name it after the suite and the target."
       ),
-      repeatCount: import_zod8.z.number().int().min(1).max(5).optional().describe("How many times to run each scenario against each target (1 to 5, default 1)"),
-      simulatorModel: import_zod8.z.string().optional().describe("Model that plays the user. Omit for the project default."),
-      judgeModel: import_zod8.z.string().optional().describe("Model that judges the criteria. Omit for the project default."),
+      repeatCount: import_zod9.z.number().int().min(1).max(5).optional().describe("How many times to run each scenario against each target (1 to 5, default 1)"),
+      simulatorModel: import_zod9.z.string().optional().describe("Model that plays the user. Omit for the project default."),
+      judgeModel: import_zod9.z.string().optional().describe("Model that judges the criteria. Omit for the project default."),
       parameters: runParametersSchema.optional().describe(
         "Values for the parameters the scenarios declare, by name. They apply to every target; a target that names the same parameter overrides them for itself."
       ),
-      note: import_zod8.z.string().max(200).optional().describe("One short line saying why this run was started (max 200 characters)")
+      note: import_zod9.z.string().max(200).optional().describe("One short line saying why this run was started (max 200 characters)")
     },
     withToolLogging("platform_run_test_suite", async (params) => {
       requireApiKey();
@@ -8273,10 +8383,10 @@ function registerSimulationRunTools(server) {
     "platform_list_simulation_runs",
     "List simulation run results. Filter by scenario set or batch run ID to see specific results.",
     {
-      scenarioSetId: import_zod8.z.string().optional().describe("Filter by scenario set ID"),
-      batchRunId: import_zod8.z.string().optional().describe("Filter by batch run ID"),
-      limit: import_zod8.z.number().optional().describe("Max results to return (default: 20)"),
-      format: import_zod8.z.enum(["digest", "json"]).optional().describe("Output format")
+      scenarioSetId: import_zod9.z.string().optional().describe("Filter by scenario set ID"),
+      batchRunId: import_zod9.z.string().optional().describe("Filter by batch run ID"),
+      limit: import_zod9.z.number().optional().describe("Max results to return (default: 20)"),
+      format: import_zod9.z.enum(["digest", "json"]).optional().describe("Output format")
     },
     withToolLogging("platform_list_simulation_runs", async (params) => {
       requireApiKey();
@@ -8290,8 +8400,8 @@ function registerSimulationRunTools(server) {
     "platform_get_simulation_run",
     "Get full details of a simulation run including conversation messages, results, costs, the verdict and the result of every evaluator attached to its test suite or run plan.",
     {
-      scenarioRunId: import_zod8.z.string().describe("The simulation run ID"),
-      format: import_zod8.z.enum(["digest", "json"]).optional().describe("Output format")
+      scenarioRunId: import_zod9.z.string().describe("The simulation run ID"),
+      format: import_zod9.z.enum(["digest", "json"]).optional().describe("Output format")
     },
     withToolLogging("platform_get_simulation_run", async (params) => {
       requireApiKey();
@@ -8307,8 +8417,8 @@ function registerEvaluatorTools(server) {
     "platform_create_evaluator",
     `Create an evaluator on the LangWatch platform. Useful for setting up LLM-as-judge and other evaluators to use in evaluation notebooks. Call discover_schema({ category: 'evaluators' }) first to see available evaluator types and their settings.`,
     {
-      name: import_zod8.z.string().describe("Evaluator name"),
-      config: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown()).describe(
+      name: import_zod9.z.string().describe("Evaluator name"),
+      config: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.unknown()).describe(
         'Evaluator config object. Must include "evaluatorType" (e.g. "langevals/llm_boolean") and optional "settings" overrides.'
       )
     },
@@ -8336,7 +8446,7 @@ function registerEvaluatorTools(server) {
     "platform_get_evaluator",
     "Get full details of an evaluator on the LangWatch platform by ID or slug, including config, input fields, and output fields.",
     {
-      idOrSlug: import_zod8.z.string().describe("The evaluator ID or slug to retrieve")
+      idOrSlug: import_zod9.z.string().describe("The evaluator ID or slug to retrieve")
     },
     withToolLogging("platform_get_evaluator", async (params) => {
       requireApiKey();
@@ -8350,9 +8460,9 @@ function registerEvaluatorTools(server) {
     "platform_update_evaluator",
     "Update an existing evaluator on the LangWatch platform. The evaluatorType in config cannot be changed after creation.",
     {
-      evaluatorId: import_zod8.z.string().describe("The evaluator ID to update"),
-      name: import_zod8.z.string().optional().describe("Updated evaluator name"),
-      config: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown()).optional().describe("Updated config settings. Note: evaluatorType cannot be changed after creation.")
+      evaluatorId: import_zod9.z.string().describe("The evaluator ID to update"),
+      name: import_zod9.z.string().optional().describe("Updated evaluator name"),
+      config: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.unknown()).optional().describe("Updated config settings. Note: evaluatorType cannot be changed after creation.")
     },
     withToolLogging("platform_update_evaluator", async (params) => {
       requireApiKey();
@@ -8366,7 +8476,7 @@ function registerEvaluatorTools(server) {
     "platform_delete_evaluator",
     "Archive (soft-delete) an evaluator by ID or slug.",
     {
-      idOrSlug: import_zod8.z.string().describe("The evaluator ID or slug to archive")
+      idOrSlug: import_zod9.z.string().describe("The evaluator ID or slug to archive")
     },
     withToolLogging("platform_delete_evaluator", async (params) => {
       requireApiKey();
@@ -8382,12 +8492,12 @@ function registerModelProviderTools(server) {
     "platform_set_model_provider",
     `Set or update a model provider on the LangWatch platform. Use this to configure API keys (e.g. OPENAI_API_KEY) needed to run evaluators. The API key is stored securely and never returned in responses. Omit customKeys to update other settings without changing existing keys.`,
     {
-      provider: import_zod8.z.string().describe('Provider name, e.g., "openai", "anthropic", "azure", "custom"'),
-      enabled: import_zod8.z.boolean().describe("Whether the provider is enabled"),
-      customKeys: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown()).optional().describe(
+      provider: import_zod9.z.string().describe('Provider name, e.g., "openai", "anthropic", "azure", "custom"'),
+      enabled: import_zod9.z.boolean().describe("Whether the provider is enabled"),
+      customKeys: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.unknown()).optional().describe(
         'API key configuration, e.g. { "OPENAI_API_KEY": "sk-..." }. Omit to keep existing keys.'
       ),
-      defaultModel: import_zod8.z.string().optional().describe("Set as project default model")
+      defaultModel: import_zod9.z.string().optional().describe("Set as project default model")
     },
     withToolLogging("platform_set_model_provider", async (params) => {
       requireApiKey();
@@ -8427,7 +8537,7 @@ function registerAgentTools(server) {
     "platform_get_agent",
     "Get detailed information about a specific agent by its ID, including its configuration. A connected agent also shows its environment, status, the run parameters it declared (with options and defaults) and the instances connected right now.",
     {
-      id: import_zod8.z.string().describe("The agent ID")
+      id: import_zod9.z.string().describe("The agent ID")
     },
     withToolLogging("platform_get_agent", async (params) => {
       requireApiKey();
@@ -8441,9 +8551,9 @@ function registerAgentTools(server) {
     "platform_create_agent",
     "Create a new agent. Supported types: 'signature' (LLM prompt), 'code' (Python), 'workflow' (sub-workflow), 'http' (external API). A 'connected' agent is not created here: it registers itself from code, with connectAgent from langwatch/agent in TypeScript or langwatch.connect_agent in Python, and appears in the list once that process runs.",
     {
-      name: import_zod8.z.string().describe("Agent name"),
-      type: import_zod8.z.enum(["signature", "code", "workflow", "http"]).describe("Agent type"),
-      config: import_zod8.z.string().optional().describe("Agent configuration as JSON string (will be parsed)")
+      name: import_zod9.z.string().describe("Agent name"),
+      type: import_zod9.z.enum(["signature", "code", "workflow", "http"]).describe("Agent type"),
+      config: import_zod9.z.string().optional().describe("Agent configuration as JSON string (will be parsed)")
     },
     withToolLogging("platform_create_agent", async (params) => {
       requireApiKey();
@@ -8460,10 +8570,10 @@ function registerAgentTools(server) {
     "platform_update_agent",
     "Update an existing agent's name, type, or configuration.",
     {
-      id: import_zod8.z.string().describe("The agent ID"),
-      name: import_zod8.z.string().optional().describe("New agent name"),
-      type: import_zod8.z.string().optional().describe("New agent type: signature, code, workflow, or http"),
-      config: import_zod8.z.string().optional().describe("Updated configuration as JSON string (will be parsed)")
+      id: import_zod9.z.string().describe("The agent ID"),
+      name: import_zod9.z.string().optional().describe("New agent name"),
+      type: import_zod9.z.string().optional().describe("New agent type: signature, code, workflow, or http"),
+      config: import_zod9.z.string().optional().describe("Updated configuration as JSON string (will be parsed)")
     },
     withToolLogging("platform_update_agent", async (params) => {
       requireApiKey();
@@ -8480,7 +8590,7 @@ function registerAgentTools(server) {
     "platform_delete_agent",
     "Archive (soft-delete) an agent by its ID.",
     {
-      id: import_zod8.z.string().describe("The agent ID to archive")
+      id: import_zod9.z.string().describe("The agent ID to archive")
     },
     withToolLogging("platform_delete_agent", async (params) => {
       requireApiKey();
@@ -8494,13 +8604,13 @@ function registerAgentTools(server) {
     "platform_run_agent",
     "Run one turn of an agent. A connected agent runs through the platform relay on a live instance: give `message` (one user turn) or `input` with a `messages` list, plus `parameters` and `threadId` to continue a conversation. HTTP agents call their configured URL directly; workflow-linked agents execute via the workflow engine.",
     {
-      id: import_zod8.z.string().describe("The agent ID to run"),
-      input: import_zod8.z.string().optional().describe(
+      id: import_zod9.z.string().describe("The agent ID to run"),
+      input: import_zod9.z.string().optional().describe(
         "Input data as a JSON object string. For a connected agent it is the relay body: messages (OpenAI style), and optionally threadId, session and params."
       ),
-      message: import_zod8.z.string().optional().describe("One user message to send to a connected agent, instead of input"),
-      parameters: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number(), import_zod8.z.boolean()])).optional().describe("Run parameter values for a connected agent, by name"),
-      threadId: import_zod8.z.string().optional().describe("Continue a conversation on a connected agent")
+      message: import_zod9.z.string().optional().describe("One user message to send to a connected agent, instead of input"),
+      parameters: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number(), import_zod9.z.boolean()])).optional().describe("Run parameter values for a connected agent, by name"),
+      threadId: import_zod9.z.string().optional().describe("Continue a conversation on a connected agent")
     },
     withToolLogging("platform_run_agent", async (params) => {
       requireApiKey();
@@ -8514,7 +8624,7 @@ function registerAgentTools(server) {
     "platform_test_agent",
     'Test an agent with one scripted scenario run: the user sends "ping", the agent answers, and the run succeeds when the answer arrives. No model is used, and no scenario, run plan or test suite is added to the project. Answers at once with the scenario run id to follow with platform_get_simulation_run; the run itself is asynchronous.',
     {
-      id: import_zod8.z.string().describe("The agent ID to test")
+      id: import_zod9.z.string().describe("The agent ID to test")
     },
     withToolLogging("platform_test_agent", async (params) => {
       requireApiKey();
@@ -8524,91 +8634,103 @@ function registerAgentTools(server) {
     })
   );
 }
-function registerDashboardTools(server) {
+function registerAnalyticsReportTools(server) {
   server.tool(
-    "platform_list_dashboards",
-    "List all analytics dashboards in the LangWatch project.",
+    "platform_list_analytics_reports",
+    "List the Analytics Reports in the LangWatch project (/api/v1/analytics/reports). Dashboards, which hold widgets, are listed by list_dashboards.",
     {},
-    withToolLogging("platform_list_dashboards", async () => {
+    withToolLogging("platform_list_analytics_reports", async () => {
       requireApiKey();
-      const { handleListDashboards: handleListDashboards2 } = await Promise.resolve().then(() => (init_list_dashboards(), list_dashboards_exports));
+      const { handleListAnalyticsReports: handleListAnalyticsReports2 } = await Promise.resolve().then(() => (init_list_analytics_reports(), list_analytics_reports_exports));
       return {
-        content: [{ type: "text", text: await handleListDashboards2() }]
+        content: [{ type: "text", text: await handleListAnalyticsReports2() }]
       };
     })
   );
   server.tool(
-    "platform_get_dashboard",
-    "Get a dashboard by its ID, including its graphs.",
+    "platform_get_analytics_report",
+    "Get an Analytics Report by its ID, including its graphs. A Dashboards dashboard's ID is not found here; read it with get_dashboard.",
     {
-      id: import_zod8.z.string().describe("The dashboard ID")
+      reportId: import_zod9.z.string().describe("The Analytics Report ID")
     },
-    withToolLogging("platform_get_dashboard", async (params) => {
+    withToolLogging("platform_get_analytics_report", async (params) => {
       requireApiKey();
-      const { handleGetDashboard: handleGetDashboard2 } = await Promise.resolve().then(() => (init_get_dashboard(), get_dashboard_exports));
+      const { handleGetAnalyticsReport: handleGetAnalyticsReport2 } = await Promise.resolve().then(() => (init_get_analytics_report(), get_analytics_report_exports));
       return {
-        content: [{ type: "text", text: await handleGetDashboard2(params) }]
+        content: [{ type: "text", text: await handleGetAnalyticsReport2(params) }]
       };
     })
   );
   server.tool(
-    "platform_create_dashboard",
-    "Create a new analytics dashboard.",
+    "platform_create_analytics_report",
+    "Create a new Analytics Report.",
     {
-      name: import_zod8.z.string().describe("Dashboard name")
+      name: import_zod9.z.string().describe("Analytics Report name")
     },
-    withToolLogging("platform_create_dashboard", async (params) => {
+    withToolLogging("platform_create_analytics_report", async (params) => {
       requireApiKey();
-      const { handleCreateDashboard: handleCreateDashboard2 } = await Promise.resolve().then(() => (init_create_dashboard(), create_dashboard_exports));
+      const { handleCreateAnalyticsReport: handleCreateAnalyticsReport2 } = await Promise.resolve().then(() => (init_create_analytics_report(), create_analytics_report_exports));
       return {
-        content: [{ type: "text", text: await handleCreateDashboard2(params) }]
+        content: [
+          {
+            type: "text",
+            text: await handleCreateAnalyticsReport2(params)
+          }
+        ]
       };
     })
   );
   server.tool(
-    "platform_delete_dashboard",
-    "Delete a dashboard and all its graphs.",
+    "platform_delete_analytics_report",
+    "Delete an Analytics Report and all its graphs.",
     {
-      id: import_zod8.z.string().describe("The dashboard ID to delete")
+      reportId: import_zod9.z.string().describe("The Analytics Report ID to delete")
     },
-    withToolLogging("platform_delete_dashboard", async (params) => {
+    withToolLogging("platform_delete_analytics_report", async (params) => {
       requireApiKey();
-      const { handleDeleteDashboard: handleDeleteDashboard2 } = await Promise.resolve().then(() => (init_delete_dashboard(), delete_dashboard_exports));
+      const { handleDeleteAnalyticsReport: handleDeleteAnalyticsReport2 } = await Promise.resolve().then(() => (init_delete_analytics_report(), delete_analytics_report_exports));
       return {
-        content: [{ type: "text", text: await handleDeleteDashboard2(params) }]
+        content: [
+          {
+            type: "text",
+            text: await handleDeleteAnalyticsReport2(params)
+          }
+        ]
       };
     })
   );
   server.tool(
-    "platform_rename_dashboard",
-    "Rename a dashboard.",
+    "platform_rename_analytics_report",
+    "Rename an Analytics Report.",
     {
-      id: import_zod8.z.string().describe("The dashboard ID to rename"),
-      name: import_zod8.z.string().describe("The new name for the dashboard")
+      reportId: import_zod9.z.string().describe("The Analytics Report ID to rename"),
+      name: import_zod9.z.string().describe("The new name for the Analytics Report")
     },
-    withToolLogging("platform_rename_dashboard", async (params) => {
+    withToolLogging("platform_rename_analytics_report", async (params) => {
       requireApiKey();
-      const { renameDashboard: renameDashboard2 } = await Promise.resolve().then(() => (init_langwatch_api_dashboards(), langwatch_api_dashboards_exports));
-      const result = await renameDashboard2(params.id, { name: params.name });
+      const { renameAnalyticsReport: renameAnalyticsReport2 } = await Promise.resolve().then(() => (init_langwatch_api_analytics_reports(), langwatch_api_analytics_reports_exports));
+      const result = await renameAnalyticsReport2({ reportId: params.reportId, name: params.name });
       return {
         content: [
           {
             type: "text",
-            text: `Dashboard "${result.name}" renamed successfully (ID: ${result.id}).`
+            text: `Analytics Report "${result.name}" renamed successfully (ID: ${result.id}).`
           }
         ]
       };
     })
   );
+}
+function registerDashboardTools(server) {
   server.tool(
-    "list_dashboard_boards",
-    "Lists the project's boards in the Dashboards area, with each one's ID and widget count. Use an ID from here as the dashboardId of add_dashboard_widget and update_dashboard_widget; the analytics dashboards platform_list_dashboards lists hold no widgets.",
+    "list_dashboards",
+    "Lists the project's dashboards in the Dashboards area, with each one's ID and widget count. Use an ID from here as the dashboardId of add_dashboard_widget and update_dashboard_widget; the Analytics Reports platform_list_analytics_reports lists hold no widgets.",
     {},
-    withToolLogging("list_dashboard_boards", async () => {
+    withToolLogging("list_dashboards", async () => {
       requireApiKey();
-      const { handleListDashboardBoards: handleListDashboardBoards2 } = await Promise.resolve().then(() => (init_list_dashboard_boards(), list_dashboard_boards_exports));
+      const { handleListDashboards: handleListDashboards2 } = await Promise.resolve().then(() => (init_list_dashboards(), list_dashboards_exports));
       return {
-        content: [{ type: "text", text: await handleListDashboardBoards2() }]
+        content: [{ type: "text", text: await handleListDashboards2() }]
       };
     })
   );
@@ -8616,22 +8738,23 @@ function registerDashboardTools(server) {
     "add_dashboard_widget",
     "Creates a custom dashboard widget and places it on the given dashboard. A widget's `code` is a TSX file run in a sandbox: it receives a global `LW` with `LW.useChartQuery(name)` (reads one of the widget's own named queries), `LW.navigate` and `LW.theme`. `queries` are named LangWatchQL SQL statements the code can read by name \u2014 validate each statement's SQL first with run_query before calling this tool, since a query only runs inside the sandbox at render time and a mistake surfaces there, not here. Up to 8 queries per widget.",
     {
-      dashboardId: import_zod8.z.string().describe("The Dashboards board to add the widget to, as list_dashboard_boards lists it"),
-      name: import_zod8.z.string().describe("The widget's display name"),
-      code: import_zod8.z.string().describe(
+      dashboardId: import_zod9.z.string().describe("The dashboard to add the widget to, as list_dashboards lists it"),
+      name: import_zod9.z.string().describe("The widget's display name"),
+      code: import_zod9.z.string().describe(
         "The widget's TSX source. Runs sandboxed with a global LW (LW.useChartQuery(name), LW.navigate, LW.theme) in scope."
       ),
-      queries: import_zod8.z.union([
-        import_zod8.z.record(import_zod8.z.string(), import_zod8.z.string()).describe('{"<name>": "<LWQL SQL>"}'),
-        import_zod8.z.array(
-          import_zod8.z.object({
-            name: import_zod8.z.string().describe('Referenced from code as LW.useChartQuery("name")'),
-            sql: import_zod8.z.string().describe("The LangWatchQL statement")
+      queries: import_zod9.z.union([
+        import_zod9.z.record(import_zod9.z.string(), import_zod9.z.string()).describe('{"<name>": "<LWQL SQL>"}'),
+        import_zod9.z.array(
+          import_zod9.z.object({
+            name: import_zod9.z.string().describe('Referenced from code as LW.useChartQuery("name")'),
+            sql: import_zod9.z.string().describe("The LangWatchQL statement")
           })
         ).describe("Named LWQL queries, array form")
       ]).describe(
         "The widget's named LangWatchQL queries: either {name: sql} or an array of {name, sql}. Max 8. Validate each statement with run_query first."
-      )
+      ),
+      sources: widgetSourcesInput
     },
     withToolLogging("add_dashboard_widget", async (params) => {
       requireApiKey();
@@ -8643,26 +8766,27 @@ function registerDashboardTools(server) {
   );
   server.tool(
     "update_dashboard_widget",
-    "Changes one custom widget on a dashboard: its name, its TSX `code`, its named LangWatchQL `queries` or its `description`. Pass only the fields to change; every field left out keeps its stored value. Validate any new query's SQL with run_query first. Returns the updated widget.",
+    "Changes one custom widget on a dashboard: its name, its TSX `code`, its named LangWatchQL `queries`, its `description` or the `sources` its queries count. Pass only the fields to change; every field left out keeps its stored value. Validate any new query's SQL with run_query first. Returns the updated widget.",
     {
-      dashboardId: import_zod8.z.string().describe("The dashboard the widget is on"),
-      widgetId: import_zod8.z.string().describe("The widget to change, as add_dashboard_widget returned it"),
-      name: import_zod8.z.string().optional().describe("The widget's new display name"),
-      code: import_zod8.z.string().optional().describe(
+      dashboardId: import_zod9.z.string().describe("The dashboard the widget is on"),
+      widgetId: import_zod9.z.string().describe("The widget to change, as add_dashboard_widget returned it"),
+      name: import_zod9.z.string().optional().describe("The widget's new display name"),
+      code: import_zod9.z.string().optional().describe(
         "The widget's new TSX source. Runs sandboxed with a global LW (LW.useChartQuery(name), LW.navigate, LW.theme) in scope."
       ),
-      queries: import_zod8.z.union([
-        import_zod8.z.record(import_zod8.z.string(), import_zod8.z.string()).describe('{"<name>": "<LWQL SQL>"}'),
-        import_zod8.z.array(
-          import_zod8.z.object({
-            name: import_zod8.z.string().describe('Referenced from code as LW.useChartQuery("name")'),
-            sql: import_zod8.z.string().describe("The LangWatchQL statement")
+      queries: import_zod9.z.union([
+        import_zod9.z.record(import_zod9.z.string(), import_zod9.z.string()).describe('{"<name>": "<LWQL SQL>"}'),
+        import_zod9.z.array(
+          import_zod9.z.object({
+            name: import_zod9.z.string().describe('Referenced from code as LW.useChartQuery("name")'),
+            sql: import_zod9.z.string().describe("The LangWatchQL statement")
           })
         ).describe("Named LWQL queries, array form")
       ]).optional().describe(
         "The widget's new named LangWatchQL queries, replacing the stored set: either {name: sql} or an array of {name, sql}. Max 8."
       ),
-      description: import_zod8.z.string().optional().describe("What the widget's info tip says: a sentence or two")
+      description: import_zod9.z.string().optional().describe("What the widget's info tip says: a sentence or two"),
+      sources: widgetSourcesInput
     },
     withToolLogging("update_dashboard_widget", async (params) => {
       requireApiKey();
@@ -8672,6 +8796,78 @@ function registerDashboardTools(server) {
       };
     })
   );
+  registerDashboardCrudTools(server);
+}
+function registerDashboardCrudTools(server) {
+  const dashboardId = import_zod9.z.string().describe("The dashboard's ID, as list_dashboards lists it");
+  const text = (value) => ({ content: [{ type: "text", text: value }] });
+  server.tool(
+    "get_dashboard",
+    "Reads one dashboard in the Dashboards area: its name, scope, description and address. An Analytics Report's ID is not found here; read it with platform_get_analytics_report.",
+    { dashboardId },
+    withToolLogging("get_dashboard", async (params) => {
+      requireApiKey();
+      const { handleGetDashboard: handleGetDashboard2 } = await Promise.resolve().then(() => (init_dashboards(), dashboards_exports));
+      return text(await handleGetDashboard2(params));
+    })
+  );
+  server.tool(
+    "create_dashboard",
+    "Creates an empty dashboard in the Dashboards area. Add widgets to it with add_dashboard_widget.",
+    { name: import_zod9.z.string().describe("The dashboard's name") },
+    withToolLogging("create_dashboard", async (params) => {
+      requireApiKey();
+      const { handleCreateDashboard: handleCreateDashboard2 } = await Promise.resolve().then(() => (init_dashboards(), dashboards_exports));
+      return text(await handleCreateDashboard2(params));
+    })
+  );
+  server.tool(
+    "rename_dashboard",
+    "Changes a dashboard's name and/or description; a field left out keeps its value.",
+    {
+      dashboardId,
+      name: import_zod9.z.string().optional().describe("The dashboard's new name"),
+      description: import_zod9.z.string().optional().describe("The dashboard's new description")
+    },
+    withToolLogging("rename_dashboard", async (params) => {
+      requireApiKey();
+      const { handleRenameDashboard: handleRenameDashboard2 } = await Promise.resolve().then(() => (init_dashboards(), dashboards_exports));
+      return text(await handleRenameDashboard2(params));
+    })
+  );
+  server.tool(
+    "delete_dashboard",
+    "Deletes a dashboard together with the widgets on it. This cannot be undone.",
+    { dashboardId },
+    withToolLogging("delete_dashboard", async (params) => {
+      requireApiKey();
+      const { handleDeleteDashboard: handleDeleteDashboard2 } = await Promise.resolve().then(() => (init_dashboards(), dashboards_exports));
+      return text(await handleDeleteDashboard2(params));
+    })
+  );
+  server.tool(
+    "list_dashboard_widgets",
+    "Lists the custom widgets on one dashboard, with each widget's ID and query names.",
+    { dashboardId },
+    withToolLogging("list_dashboard_widgets", async (params) => {
+      requireApiKey();
+      const { handleListDashboardWidgets: handleListDashboardWidgets2 } = await Promise.resolve().then(() => (init_dashboards(), dashboards_exports));
+      return text(await handleListDashboardWidgets2(params));
+    })
+  );
+  server.tool(
+    "delete_dashboard_widget",
+    "Deletes one custom widget from a dashboard. A widget on another dashboard is not found.",
+    {
+      dashboardId,
+      widgetId: import_zod9.z.string().describe("The widget's ID, as list_dashboard_widgets lists it")
+    },
+    withToolLogging("delete_dashboard_widget", async (params) => {
+      requireApiKey();
+      const { handleDeleteDashboardWidget: handleDeleteDashboardWidget2 } = await Promise.resolve().then(() => (init_dashboards(), dashboards_exports));
+      return text(await handleDeleteDashboardWidget2(params));
+    })
+  );
 }
 function registerWorkflowTools(server) {
   server.tool(
@@ -8690,7 +8886,7 @@ function registerWorkflowTools(server) {
     "platform_get_workflow",
     "Get a workflow by its ID.",
     {
-      id: import_zod8.z.string().describe("The workflow ID")
+      id: import_zod9.z.string().describe("The workflow ID")
     },
     withToolLogging("platform_get_workflow", async (params) => {
       requireApiKey();
@@ -8704,7 +8900,7 @@ function registerWorkflowTools(server) {
     "platform_delete_workflow",
     "Archive (soft-delete) a workflow by its ID.",
     {
-      id: import_zod8.z.string().describe("The workflow ID to archive")
+      id: import_zod9.z.string().describe("The workflow ID to archive")
     },
     withToolLogging("platform_delete_workflow", async (params) => {
       requireApiKey();
@@ -8718,8 +8914,8 @@ function registerWorkflowTools(server) {
     "platform_run_workflow",
     "Execute a workflow with JSON input. Returns the workflow output.",
     {
-      id: import_zod8.z.string().describe("The workflow ID to run"),
-      input: import_zod8.z.string().optional().describe("Input data as a JSON object string")
+      id: import_zod9.z.string().describe("The workflow ID to run"),
+      input: import_zod9.z.string().optional().describe("Input data as a JSON object string")
     },
     withToolLogging("platform_run_workflow", async (params) => {
       requireApiKey();
@@ -8735,7 +8931,7 @@ function registerAnnotationTools(server) {
     "platform_list_annotations",
     "List all annotations for the project, optionally filtered by trace ID.",
     {
-      traceId: import_zod8.z.string().optional().describe("Filter annotations by trace ID")
+      traceId: import_zod9.z.string().optional().describe("Filter annotations by trace ID")
     },
     withToolLogging("platform_list_annotations", async (params) => {
       requireApiKey();
@@ -8749,10 +8945,10 @@ function registerAnnotationTools(server) {
     "platform_create_annotation",
     "Create an annotation (thumbs up/down, comment) for a trace.",
     {
-      traceId: import_zod8.z.string().describe("The trace ID to annotate"),
-      comment: import_zod8.z.string().optional().describe("Annotation comment"),
-      isThumbsUp: import_zod8.z.boolean().optional().describe("True for positive feedback, false for negative"),
-      email: import_zod8.z.string().optional().describe("Email of the annotator")
+      traceId: import_zod9.z.string().describe("The trace ID to annotate"),
+      comment: import_zod9.z.string().optional().describe("Annotation comment"),
+      isThumbsUp: import_zod9.z.boolean().optional().describe("True for positive feedback, false for negative"),
+      email: import_zod9.z.string().optional().describe("Email of the annotator")
     },
     withToolLogging("platform_create_annotation", async (params) => {
       requireApiKey();
@@ -8766,7 +8962,7 @@ function registerAnnotationTools(server) {
     "platform_delete_annotation",
     "Delete an annotation by its ID.",
     {
-      id: import_zod8.z.string().describe("The annotation ID to delete")
+      id: import_zod9.z.string().describe("The annotation ID to delete")
     },
     withToolLogging("platform_delete_annotation", async (params) => {
       requireApiKey();
@@ -8780,7 +8976,7 @@ function registerAnnotationTools(server) {
     "platform_get_annotation",
     "Get annotation details by ID.",
     {
-      id: import_zod8.z.string().describe("The annotation ID")
+      id: import_zod9.z.string().describe("The annotation ID")
     },
     withToolLogging("platform_get_annotation", async (params) => {
       requireApiKey();
@@ -8804,7 +9000,7 @@ function registerTriggerTools(server) {
     "platform_list_triggers",
     "List all triggers (automations) in the project. Triggers automate actions like sending emails, Slack messages, or adding to datasets when conditions are met.",
     {
-      format: import_zod8.z.enum(["digest", "json"]).optional().describe("Output format")
+      format: import_zod9.z.enum(["digest", "json"]).optional().describe("Output format")
     },
     withToolLogging("platform_list_triggers", async (params) => {
       requireApiKey();
@@ -8816,7 +9012,7 @@ function registerTriggerTools(server) {
     "platform_get_trigger",
     "Read one trigger (automation) by its ID, including its delivery configuration. Credential values come back as [redacted]; sending them back unchanged on an update keeps the stored values.",
     {
-      id: import_zod8.z.string().describe("The trigger ID")
+      id: import_zod9.z.string().describe("The trigger ID")
     },
     withToolLogging("platform_get_trigger", async (params) => {
       requireApiKey();
@@ -8837,17 +9033,17 @@ function registerTriggerTools(server) {
       "The delivery channel cannot be changed afterwards."
     ].join("\n"),
     {
-      name: import_zod8.z.string().describe("Trigger name"),
+      name: import_zod9.z.string().describe("Trigger name"),
       action: triggerActionSchema.describe("Which channel it delivers on"),
       actionParams: actionParamsSchema.optional().describe("The delivery configuration the channel named in `action` reads. Defaults to {}"),
-      filters: import_zod8.z.string().optional().describe(TRIGGER_FILTERS_DESCRIPTION),
-      filterQuery: import_zod8.z.string().optional().describe(TRIGGER_FILTER_QUERY_DESCRIPTION),
-      customGraphId: import_zod8.z.string().optional().describe("Set to make this an alert on that graph"),
+      filters: import_zod9.z.string().optional().describe(TRIGGER_FILTERS_DESCRIPTION),
+      filterQuery: import_zod9.z.string().optional().describe(TRIGGER_FILTER_QUERY_DESCRIPTION),
+      customGraphId: import_zod9.z.string().optional().describe("Set to make this an alert on that graph"),
       graphAlert: graphAlertSchema.optional(),
       report: reportSchema.optional().describe("Set to make this a scheduled report"),
       templates: templatesSchema.optional(),
       notificationCadence: notificationCadenceSchema.optional(),
-      message: import_zod8.z.string().optional().describe("Custom alert message"),
+      message: import_zod9.z.string().optional().describe("Custom alert message"),
       alertType: alertTypeSchema.optional().describe("Alert severity. Required for a graph alert.")
     },
     withToolLogging("platform_create_trigger", async (params) => {
@@ -8865,17 +9061,17 @@ function registerTriggerTools(server) {
       "The delivery channel, the kind of automation and an alert's graph cannot be changed."
     ].join("\n"),
     {
-      id: import_zod8.z.string().describe("The trigger ID"),
-      name: import_zod8.z.string().optional().describe("New name"),
-      active: import_zod8.z.boolean().optional().describe("Resume or pause it"),
+      id: import_zod9.z.string().describe("The trigger ID"),
+      name: import_zod9.z.string().optional().describe("New name"),
+      active: import_zod9.z.boolean().optional().describe("Resume or pause it"),
       actionParams: actionParamsSchema.optional().describe("The delivery configuration this automation should have from now on"),
-      filters: import_zod8.z.string().optional().describe(TRIGGER_FILTERS_DESCRIPTION),
-      filterQuery: import_zod8.z.string().nullable().optional().describe(`${TRIGGER_FILTER_QUERY_DESCRIPTION} null clears the saved query.`),
+      filters: import_zod9.z.string().optional().describe(TRIGGER_FILTERS_DESCRIPTION),
+      filterQuery: import_zod9.z.string().nullable().optional().describe(`${TRIGGER_FILTER_QUERY_DESCRIPTION} null clears the saved query.`),
       graphAlert: graphAlertSchema.optional().describe("Only for an automation that is already a graph alert"),
       report: reportSchema.optional().describe("Only for an automation that is already a scheduled report"),
       templates: templatesSchema.optional(),
       notificationCadence: notificationCadenceSchema.optional(),
-      message: import_zod8.z.string().nullable().optional().describe("New alert message. null removes the custom message"),
+      message: import_zod9.z.string().nullable().optional().describe("New alert message. null removes the custom message"),
       alertType: alertTypeSchema.nullable().optional().describe("New alert severity. null clears it")
     },
     withToolLogging("platform_update_trigger", async (params) => {
@@ -8909,7 +9105,7 @@ function registerTriggerTools(server) {
     "platform_test_fire_trigger",
     "Send a trigger's message to the destination it is configured with, to confirm it arrives. Nothing is recorded as a fire.",
     {
-      id: import_zod8.z.string().describe("The trigger ID")
+      id: import_zod9.z.string().describe("The trigger ID")
     },
     withToolLogging("platform_test_fire_trigger", async (params) => {
       requireApiKey();
@@ -8922,9 +9118,9 @@ function registerTriggerTools(server) {
     "platform_list_trigger_fires",
     "What an automation has done, newest first. Metadata only \u2014 no message content. Answers with `nextCursor`; pass it back as `cursor` for the next page (null means there is none).",
     {
-      id: import_zod8.z.string().describe("The trigger ID"),
-      limit: import_zod8.z.number().int().positive().optional().describe("How many fires to return"),
-      cursor: import_zod8.z.string().optional().describe("The `nextCursor` a previous call answered with")
+      id: import_zod9.z.string().describe("The trigger ID"),
+      limit: import_zod9.z.number().int().positive().optional().describe("How many fires to return"),
+      cursor: import_zod9.z.string().optional().describe("The `nextCursor` a previous call answered with")
     },
     withToolLogging("platform_list_trigger_fires", async (params) => {
       requireApiKey();
@@ -8936,7 +9132,7 @@ function registerTriggerTools(server) {
     "platform_delete_trigger",
     "Delete a trigger (automation).",
     {
-      id: import_zod8.z.string().describe("The trigger ID to delete")
+      id: import_zod9.z.string().describe("The trigger ID to delete")
     },
     withToolLogging("platform_delete_trigger", async (params) => {
       requireApiKey();
@@ -8976,7 +9172,7 @@ ${lines.join("\n")}`
     "platform_get_monitor",
     "Get details of a specific online evaluation monitor.",
     {
-      id: import_zod8.z.string().describe("The monitor ID")
+      id: import_zod9.z.string().describe("The monitor ID")
     },
     withToolLogging("platform_get_monitor", async (params) => {
       requireApiKey();
@@ -8999,11 +9195,11 @@ ${lines.join("\n")}`
     "platform_create_monitor",
     "Create a new online evaluation monitor that runs an evaluator on incoming traces.",
     {
-      name: import_zod8.z.string().describe("Monitor name"),
-      checkType: import_zod8.z.string().describe("Evaluator check type (e.g. ragas/toxicity, custom/my-eval)"),
-      executionMode: import_zod8.z.enum(["ON_MESSAGE", "AS_GUARDRAIL", "MANUALLY"]).optional().describe("When to run: ON_MESSAGE (default), AS_GUARDRAIL, or MANUALLY"),
-      sample: import_zod8.z.number().min(0).max(1).optional().describe("Sampling rate 0.0-1.0 (default: 1.0)"),
-      evaluatorId: import_zod8.z.string().optional().describe("Link to a saved evaluator by ID")
+      name: import_zod9.z.string().describe("Monitor name"),
+      checkType: import_zod9.z.string().describe("Evaluator check type (e.g. ragas/toxicity, custom/my-eval)"),
+      executionMode: import_zod9.z.enum(["ON_MESSAGE", "AS_GUARDRAIL", "MANUALLY"]).optional().describe("When to run: ON_MESSAGE (default), AS_GUARDRAIL, or MANUALLY"),
+      sample: import_zod9.z.number().min(0).max(1).optional().describe("Sampling rate 0.0-1.0 (default: 1.0)"),
+      evaluatorId: import_zod9.z.string().optional().describe("Link to a saved evaluator by ID")
     },
     withToolLogging("platform_create_monitor", async (params) => {
       requireApiKey();
@@ -9023,11 +9219,11 @@ ${lines.join("\n")}`
     "platform_update_monitor",
     "Update an existing online evaluation monitor.",
     {
-      id: import_zod8.z.string().describe("The monitor ID to update"),
-      name: import_zod8.z.string().optional().describe("New monitor name"),
-      enabled: import_zod8.z.boolean().optional().describe("Enable or disable the monitor"),
-      executionMode: import_zod8.z.enum(["ON_MESSAGE", "AS_GUARDRAIL", "MANUALLY"]).optional().describe("New execution mode"),
-      sample: import_zod8.z.number().min(0).max(1).optional().describe("New sampling rate")
+      id: import_zod9.z.string().describe("The monitor ID to update"),
+      name: import_zod9.z.string().optional().describe("New monitor name"),
+      enabled: import_zod9.z.boolean().optional().describe("Enable or disable the monitor"),
+      executionMode: import_zod9.z.enum(["ON_MESSAGE", "AS_GUARDRAIL", "MANUALLY"]).optional().describe("New execution mode"),
+      sample: import_zod9.z.number().min(0).max(1).optional().describe("New sampling rate")
     },
     withToolLogging("platform_update_monitor", async (params) => {
       requireApiKey();
@@ -9047,7 +9243,7 @@ ${lines.join("\n")}`
     "platform_delete_monitor",
     "Delete an online evaluation monitor.",
     {
-      id: import_zod8.z.string().describe("The monitor ID to delete")
+      id: import_zod9.z.string().describe("The monitor ID to delete")
     },
     withToolLogging("platform_delete_monitor", async (params) => {
       requireApiKey();
@@ -9087,8 +9283,8 @@ ${lines.join("\n")}`
     "platform_create_secret",
     "Create a new encrypted project secret. Name must be UPPER_SNAKE_CASE (e.g. MY_API_KEY).",
     {
-      name: import_zod8.z.string().describe("Secret name in UPPER_SNAKE_CASE (e.g. OPENAI_API_KEY)"),
-      value: import_zod8.z.string().describe("The secret value (will be encrypted at rest)")
+      name: import_zod9.z.string().describe("Secret name in UPPER_SNAKE_CASE (e.g. OPENAI_API_KEY)"),
+      value: import_zod9.z.string().describe("The secret value (will be encrypted at rest)")
     },
     withToolLogging("platform_create_secret", async (params) => {
       requireApiKey();
@@ -9108,8 +9304,8 @@ ${lines.join("\n")}`
     "platform_update_secret",
     "Update an existing project secret's value.",
     {
-      id: import_zod8.z.string().describe("The secret ID to update"),
-      value: import_zod8.z.string().describe("The new secret value (will be encrypted at rest)")
+      id: import_zod9.z.string().describe("The secret ID to update"),
+      value: import_zod9.z.string().describe("The new secret value (will be encrypted at rest)")
     },
     withToolLogging("platform_update_secret", async (params) => {
       requireApiKey();
@@ -9129,7 +9325,7 @@ ${lines.join("\n")}`
     "platform_delete_secret",
     "Delete a project secret.",
     {
-      id: import_zod8.z.string().describe("The secret ID to delete")
+      id: import_zod9.z.string().describe("The secret ID to delete")
     },
     withToolLogging("platform_delete_secret", async (params) => {
       requireApiKey();
@@ -9144,7 +9340,10 @@ function registerExperimentTools(server) {
     "platform_run_experiment",
     "Start an experiment run by slug. Returns a run ID for polling status.",
     {
-      slug: import_zod8.z.string().describe("The experiment slug to run")
+      slug: import_zod9.z.string().describe("The experiment slug to run"),
+      concurrency: import_zod9.z.number().int().min(1).max(24).optional().describe(
+        "Cells (one row against one target) to run at once, for this run only (default: the server's setting). Use 1 to run them one at a time, in order."
+      )
     },
     withToolLogging("platform_run_experiment", async (params) => {
       requireApiKey();
@@ -9157,8 +9356,8 @@ function registerExperimentTools(server) {
     "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: import_zod8.z.string().describe("The run ID returned from platform_run_experiment"),
-      experimentSlug: import_zod8.z.string().optional().describe(
+      runId: import_zod9.z.string().describe("The run ID returned from platform_run_experiment"),
+      experimentSlug: import_zod9.z.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."
       )
     },
@@ -9173,7 +9372,7 @@ function registerExperimentTools(server) {
     "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: import_zod8.z.number().int().positive().max(100).optional().describe("Maximum number of experiments to include (default 25, hard-capped at 100)")
+      limit: import_zod9.z.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();
@@ -9186,8 +9385,8 @@ function registerExperimentTools(server) {
     "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: import_zod8.z.string().describe("Experiment slug from platform_experiment_list (e.g. 'checkout-flow')"),
-      limit: import_zod8.z.number().int().positive().max(100).optional().describe("Maximum number of runs to include (default 25, hard-capped at 100)")
+      experimentSlug: import_zod9.z.string().describe("Experiment slug from platform_experiment_list (e.g. 'checkout-flow')"),
+      limit: import_zod9.z.number().int().positive().max(100).optional().describe("Maximum number of runs to include (default 25, hard-capped at 100)")
     },
     withToolLogging("platform_experiment_list_runs", async (params) => {
       requireApiKey();
@@ -9200,15 +9399,15 @@ function registerExperimentTools(server) {
     "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: import_zod8.z.string().describe("The run ID returned from platform_run_experiment"),
-      experimentSlug: import_zod8.z.string().optional().describe(
+      runId: import_zod9.z.string().describe("The run ID returned from platform_run_experiment"),
+      experimentSlug: import_zod9.z.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: import_zod8.z.enum(["all", "failed"]).optional().describe(
+      filter: import_zod9.z.enum(["all", "failed"]).optional().describe(
         "Filter rows: 'failed' shows only rows that errored or failed an evaluation; 'all' (default) shows everything"
       ),
-      evaluator: import_zod8.z.string().optional().describe("Show only this evaluator's results (matched on `evaluator` field)"),
-      limit: import_zod8.z.number().int().positive().max(50).optional().describe(
+      evaluator: import_zod9.z.string().optional().describe("Show only this evaluator's results (matched on `evaluator` field)"),
+      limit: import_zod9.z.number().int().positive().max(50).optional().describe(
         "Maximum number of rows to include in the markdown output (default 50, hard-capped at 50)."
       )
     },
@@ -9225,7 +9424,7 @@ function registerDatasetTools(server) {
     "platform_list_datasets",
     "List all datasets on the LangWatch platform with their names, slugs, columns, and record counts. Returns AI-readable digest by default.",
     {
-      format: import_zod8.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
+      format: import_zod9.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
     },
     async (params) => {
       const { requireApiKey: requireApiKey2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -9240,8 +9439,8 @@ function registerDatasetTools(server) {
     "platform_get_dataset",
     "Get full details of a dataset on the LangWatch platform by slug or ID, including column definitions and a preview of records.",
     {
-      slugOrId: import_zod8.z.string().describe("The dataset slug or ID to retrieve"),
-      format: import_zod8.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
+      slugOrId: import_zod9.z.string().describe("The dataset slug or ID to retrieve"),
+      format: import_zod9.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
     },
     async (params) => {
       const { requireApiKey: requireApiKey2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -9269,9 +9468,9 @@ function registerDatasetTools(server) {
     "platform_update_dataset",
     "Update an existing dataset on the LangWatch platform (name and/or column types).",
     {
-      slugOrId: import_zod8.z.string().describe("The dataset slug or ID to update"),
-      name: import_zod8.z.string().optional().describe("Updated dataset name"),
-      columnTypes: import_zod8.z.array(datasetColumnDefinitionSchema).optional().describe("Updated column definitions")
+      slugOrId: import_zod9.z.string().describe("The dataset slug or ID to update"),
+      name: import_zod9.z.string().optional().describe("Updated dataset name"),
+      columnTypes: import_zod9.z.array(datasetColumnDefinitionSchema).optional().describe("Updated column definitions")
     },
     async (params) => {
       const { requireApiKey: requireApiKey2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -9286,7 +9485,7 @@ function registerDatasetTools(server) {
     "platform_delete_dataset",
     "Delete (archive) a dataset on the LangWatch platform.",
     {
-      slugOrId: import_zod8.z.string().describe("The dataset slug or ID to delete")
+      slugOrId: import_zod9.z.string().describe("The dataset slug or ID to delete")
     },
     async (params) => {
       const { requireApiKey: requireApiKey2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -9301,10 +9500,10 @@ function registerDatasetTools(server) {
     "platform_list_dataset_records",
     "List records in a dataset on the LangWatch platform with pagination.",
     {
-      slugOrId: import_zod8.z.string().describe("The dataset slug or ID to list records from"),
-      page: import_zod8.z.number().int().min(1).optional().describe("Page number (default: 1)"),
-      limit: import_zod8.z.number().int().min(1).max(1e3).optional().describe("Records per page (default: 50, max: 1000)"),
-      format: import_zod8.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
+      slugOrId: import_zod9.z.string().describe("The dataset slug or ID to list records from"),
+      page: import_zod9.z.number().int().min(1).optional().describe("Page number (default: 1)"),
+      limit: import_zod9.z.number().int().min(1).max(1e3).optional().describe("Records per page (default: 50, max: 1000)"),
+      format: import_zod9.z.enum(["digest", "json"]).optional().describe("Output format: 'digest' (default, AI-readable) or 'json' (full raw data)")
     },
     async (params) => {
       const { requireApiKey: requireApiKey2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -9319,8 +9518,8 @@ function registerDatasetTools(server) {
     "platform_create_dataset_records",
     "Add records to a dataset on the LangWatch platform in batch (max 1000 per call).",
     {
-      slugOrId: import_zod8.z.string().describe("The dataset slug or ID to add records to"),
-      entries: import_zod8.z.array(import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown())).min(1).max(1e3).describe("Array of record entries to create (key-value objects matching dataset columns)")
+      slugOrId: import_zod9.z.string().describe("The dataset slug or ID to add records to"),
+      entries: import_zod9.z.array(import_zod9.z.record(import_zod9.z.string(), import_zod9.z.unknown())).min(1).max(1e3).describe("Array of record entries to create (key-value objects matching dataset columns)")
     },
     async (params) => {
       const { requireApiKey: requireApiKey2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -9335,9 +9534,9 @@ function registerDatasetTools(server) {
     "platform_update_dataset_record",
     "Update a single record in a dataset on the LangWatch platform.",
     {
-      slugOrId: import_zod8.z.string().describe("The dataset slug or ID containing the record"),
-      recordId: import_zod8.z.string().describe("The record ID to update"),
-      entry: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown()).describe("Updated record entry (key-value object)")
+      slugOrId: import_zod9.z.string().describe("The dataset slug or ID containing the record"),
+      recordId: import_zod9.z.string().describe("The record ID to update"),
+      entry: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.unknown()).describe("Updated record entry (key-value object)")
     },
     async (params) => {
       const { requireApiKey: requireApiKey2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -9352,8 +9551,8 @@ function registerDatasetTools(server) {
     "platform_delete_dataset_records",
     "Delete records from a dataset on the LangWatch platform by their IDs.",
     {
-      slugOrId: import_zod8.z.string().describe("The dataset slug or ID containing the records"),
-      recordIds: import_zod8.z.array(import_zod8.z.string()).min(1).max(1e3).describe("Array of record IDs to delete")
+      slugOrId: import_zod9.z.string().describe("The dataset slug or ID containing the records"),
+      recordIds: import_zod9.z.array(import_zod9.z.string()).min(1).max(1e3).describe("Array of record IDs to delete")
     },
     async (params) => {
       const { requireApiKey: requireApiKey2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -9370,8 +9569,8 @@ function registerProjectTools(server) {
     "platform_list_projects",
     "List all projects in your LangWatch organization. Requires an org-level API key.",
     {
-      page: import_zod8.z.number().int().positive().optional().describe("Page number (default: 1)"),
-      limit: import_zod8.z.number().int().positive().max(1e3).optional().describe("Results per page (default: 100)")
+      page: import_zod9.z.number().int().positive().optional().describe("Page number (default: 1)"),
+      limit: import_zod9.z.number().int().positive().max(1e3).optional().describe("Results per page (default: 100)")
     },
     withToolLogging("platform_list_projects", async (params) => {
       requireApiKey();
@@ -9385,7 +9584,7 @@ function registerProjectTools(server) {
     "platform_get_project",
     "Get details of a specific project by its ID.",
     {
-      id: import_zod8.z.string().describe("The project ID")
+      id: import_zod9.z.string().describe("The project ID")
     },
     withToolLogging("platform_get_project", async (params) => {
       requireApiKey();
@@ -9401,11 +9600,11 @@ function registerProjectTools(server) {
 
 You must provide either teamId (to add the project to an existing team) or newTeamName (to create a new team for the project).`,
     {
-      name: import_zod8.z.string().describe("Project name"),
-      language: import_zod8.z.string().describe('Programming language (e.g. "python", "typescript")'),
-      framework: import_zod8.z.string().describe('Framework (e.g. "openai", "langchain", "custom")'),
-      teamId: import_zod8.z.string().optional().describe("ID of an existing team to add the project to"),
-      newTeamName: import_zod8.z.string().optional().describe("Name for a new team to create for this project")
+      name: import_zod9.z.string().describe("Project name"),
+      language: import_zod9.z.string().describe('Programming language (e.g. "python", "typescript")'),
+      framework: import_zod9.z.string().describe('Framework (e.g. "openai", "langchain", "custom")'),
+      teamId: import_zod9.z.string().optional().describe("ID of an existing team to add the project to"),
+      newTeamName: import_zod9.z.string().optional().describe("Name for a new team to create for this project")
     },
     withToolLogging("platform_create_project", async (params) => {
       requireApiKey();
@@ -9419,11 +9618,11 @@ You must provide either teamId (to add the project to an existing team) or newTe
     "platform_update_project",
     "Update an existing project's name, language, framework, or PII redaction level.",
     {
-      id: import_zod8.z.string().describe("The project ID to update"),
-      name: import_zod8.z.string().optional().describe("New project name"),
-      language: import_zod8.z.string().optional().describe("New programming language"),
-      framework: import_zod8.z.string().optional().describe("New framework"),
-      piiRedactionLevel: import_zod8.z.enum(["STRICT", "ESSENTIAL", "DISABLED"]).optional().describe("PII redaction level")
+      id: import_zod9.z.string().describe("The project ID to update"),
+      name: import_zod9.z.string().optional().describe("New project name"),
+      language: import_zod9.z.string().optional().describe("New programming language"),
+      framework: import_zod9.z.string().optional().describe("New framework"),
+      piiRedactionLevel: import_zod9.z.enum(["STRICT", "ESSENTIAL", "DISABLED"]).optional().describe("PII redaction level")
     },
     withToolLogging("platform_update_project", async (params) => {
       requireApiKey();
@@ -9437,7 +9636,7 @@ You must provide either teamId (to add the project to an existing team) or newTe
     "platform_archive_project",
     "Archive (soft-delete) a project. The project can be restored later if needed.",
     {
-      id: import_zod8.z.string().describe("The project ID to archive")
+      id: import_zod9.z.string().describe("The project ID to archive")
     },
     withToolLogging("platform_archive_project", async (params) => {
       requireApiKey();
@@ -9470,18 +9669,18 @@ function registerApiKeyTools(server) {
 
 The token is returned once and cannot be retrieved again.`,
     {
-      keyType: import_zod8.z.enum(["personal", "service"]).describe("Key type: 'personal' (user-tied) or 'service' (headless)"),
-      name: import_zod8.z.string().describe("Key name (max 100 chars)"),
-      description: import_zod8.z.string().optional().describe("Key description (max 500 chars)"),
-      expiresAt: import_zod8.z.string().optional().describe("Expiration date (ISO string)"),
-      bindings: import_zod8.z.array(
-        import_zod8.z.object({
-          role: import_zod8.z.enum(["ADMIN", "MEMBER", "VIEWER"]).describe("Role"),
-          scopeType: import_zod8.z.enum(["ORGANIZATION", "TEAM", "PROJECT"]).describe("Scope type"),
-          scopeId: import_zod8.z.string().describe("Scope ID (org, team, or project ID)")
+      keyType: import_zod9.z.enum(["personal", "service"]).describe("Key type: 'personal' (user-tied) or 'service' (headless)"),
+      name: import_zod9.z.string().describe("Key name (max 100 chars)"),
+      description: import_zod9.z.string().optional().describe("Key description (max 500 chars)"),
+      expiresAt: import_zod9.z.string().optional().describe("Expiration date (ISO string)"),
+      bindings: import_zod9.z.array(
+        import_zod9.z.object({
+          role: import_zod9.z.enum(["ADMIN", "MEMBER", "VIEWER"]).describe("Role"),
+          scopeType: import_zod9.z.enum(["ORGANIZATION", "TEAM", "PROJECT"]).describe("Scope type"),
+          scopeId: import_zod9.z.string().describe("Scope ID (org, team, or project ID)")
         })
       ).optional().describe("Role bindings (required for personal keys)"),
-      projectIds: import_zod8.z.array(import_zod8.z.string()).optional().describe("Project IDs for service keys (creates ADMIN bindings per project)")
+      projectIds: import_zod9.z.array(import_zod9.z.string()).optional().describe("Project IDs for service keys (creates ADMIN bindings per project)")
     },
     withToolLogging("platform_create_api_key", async (params) => {
       requireApiKey();
@@ -9495,7 +9694,7 @@ The token is returned once and cannot be retrieved again.`,
     "platform_revoke_api_key",
     "Revoke an API key. Once revoked, the key can no longer be used for authentication.",
     {
-      id: import_zod8.z.string().describe("The API key ID to revoke")
+      id: import_zod9.z.string().describe("The API key ID to revoke")
     },
     withToolLogging("platform_revoke_api_key", async (params) => {
       requireApiKey();