@langwatch/mcp-server 2.1.0 → 3.0.0

package/src/tools/search-traces.ts

@@ -1,17 +1,142 @@
-import { searchTraces as apiSearchTraces } from "../langwatch-api.js";
-import { parseRelativeDate } from "../utils/date-parsing.js";
-import { formatEvaluationLines } from "../utils/format-evaluations.js";
+import { searchTraces as apiSearchTraces, type TraceSearchResult } from "../langwatch-api.ts";
+import { parseRelativeDate } from "../utils/date-parsing.ts";
+import { formatEvaluationLines } from "../utils/format-evaluations.ts";
+import { looksLikeTraceId } from "../utils/trace-id-shape.ts";
+
+const HOUR_MS = 3600000;
+const DAY_MS = 86400000;
+
+/** Default window for a text search. */
+const TEXT_SEARCH_WINDOW_MS = DAY_MS;
+
+/**
+ * Default window when trace ids are named: an exact-match intent must not be
+ * answered against yesterday alone. Mirrors the platform's 90-day id lookup
+ * bound (ADR-164).
+ */
+const ID_LOOKUP_WINDOW_MS = 90 * DAY_MS;
+
+function previewLine({
+  label,
+  text,
+}: {
+  label: string;
+  text: { value: string } | undefined;
+}): string {
+  const value = text?.value ? String(text.value) : "N/A";
+  return `- **${label}**: ${value.slice(0, 100)}${value.length > 100 ? "..." : ""}`;
+}
+
+function traceLines(trace: TraceSearchResult): string[] {
+  const lines = [`### Trace: ${trace.trace_id}`];
+
+  if (trace.formatted_trace) {
+    lines.push(trace.formatted_trace);
+  } else {
+    lines.push(previewLine({ label: "Input", text: trace.input }));
+    lines.push(previewLine({ label: "Output", text: trace.output }));
+  }
+
+  if (trace.timestamps) {
+    lines.push(`- **Time**: ${trace.timestamps.started_at || "N/A"}`);
+  }
+  if (trace.error) {
+    lines.push(`- **Error**: ${JSON.stringify(trace.error)}`);
+  }
+  if (trace.evaluations && trace.evaluations.length > 0) {
+    lines.push(...formatEvaluationLines(trace.evaluations));
+  }
+  lines.push("");
+  return lines;
+}
+
+function describeSpan({ ms }: { ms: number }): string {
+  if (ms % DAY_MS === 0) {
+    const days = ms / DAY_MS;
+    return days === 1 ? "24 hours" : `${days} days`;
+  }
+  const hours = Math.round(ms / HOUR_MS);
+  return hours === 1 ? "1 hour" : `${hours} hours`;
+}
+
+/** The next sensible window to offer, or undefined once the span is already wide. */
+function suggestWiderWindow({ spanMs }: { spanMs: number }): string | undefined {
+  if (spanMs < 7 * DAY_MS) return "7d";
+  if (spanMs < 30 * DAY_MS) return "30d";
+  if (spanMs < 90 * DAY_MS) return "90d";
+  return undefined;
+}
+
+/** An empty result states the searched window and names the tool that looks an id up. */
+function buildEmptyResult({
+  query,
+  traceIds,
+  spanMs,
+  windowWasDefaulted,
+  startDate,
+  endDate,
+}: {
+  query?: string;
+  traceIds?: string[];
+  spanMs: number;
+  windowWasDefaulted: boolean;
+  startDate: number;
+  endDate: number;
+}): string {
+  const hasTraceIds = (traceIds?.length ?? 0) > 0;
+  const lines = [
+    hasTraceIds
+      ? "No traces matched the requested trace ids in the searched window."
+      : "No traces found matching your query.",
+    "",
+  ];
+
+  const range = `${new Date(startDate).toISOString()} to ${new Date(endDate).toISOString()}`;
+  lines.push(
+    windowWasDefaulted
+      ? `Searched the last ${describeSpan({ ms: spanMs })} (the default): ${range}.`
+      : `Searched ${range}.`,
+  );
+  lines.push("", "Tips:");
+
+  if (query && looksLikeTraceId(query)) {
+    lines.push(
+      `- "${query}" looks like a trace id. Free text never matches trace ids — use \`get_trace\` with traceId: "${query}".`,
+    );
+  }
+
+  const wider = suggestWiderWindow({ spanMs });
+  if (wider) {
+    lines.push(
+      `- Widen the window with startDate, e.g. startDate: "${wider}". Accepts h (hours), d (days), w (weeks), m (30-day months), or an ISO date.`,
+    );
+  }
+
+  if (hasTraceIds) {
+    lines.push(
+      "- Retry with an earlier startDate, or relax the query and filters if you supplied them.",
+      "- Looking up one full id? `get_trace` has no time window. A unique 8–31 character hex prefix searches the last 90 days.",
+    );
+  } else {
+    lines.push(
+      "- Looking up a known trace id? `get_trace` takes a traceId. A full id has no time window; a unique 8–31 character hex prefix searches the last 90 days.",
+      "- To fetch several known trace ids at once, pass `traceIds` instead of `query`.",
+    );
+  }
+
+  return lines.join("\n");
+}
 
 /**
- * Handles the search_traces MCP tool invocation.
- *
- * Searches LangWatch traces with optional filters, text query, and date range.
- * In digest mode (default), returns AI-readable formatted digests per trace.
- * In json mode, returns the full raw JSON.
+ * Handles the search_traces MCP tool: searches with optional filters, text
+ * query, trace ids and date range. Digest mode (default) returns AI-readable
+ * digests per trace; json mode returns the full raw JSON.
  */
 export async function handleSearchTraces(params: {
   query?: string;
+  traceIds?: string[];
   filters?: Record<string, string[]>;
+  filter?: string;
   startDate?: string;
   endDate?: string;
   pageSize?: number;
@@ -19,15 +144,27 @@ export async function handleSearchTraces(params: {
   format?: "digest" | "json";
 }): Promise<string> {
   const now = Date.now();
-  const startDate = params.startDate
-    ? parseRelativeDate(params.startDate)
-    : now - 86400000;
-  const endDate = params.endDate ? parseRelativeDate(params.endDate) : now;
+  const hasTraceIds = (params.traceIds?.length ?? 0) > 0;
+  const defaultSpanMs = hasTraceIds ? ID_LOOKUP_WINDOW_MS : TEXT_SEARCH_WINDOW_MS;
+
+  const endDate = params.endDate !== undefined ? parseRelativeDate(params.endDate) : now;
+  const startDate =
+    params.startDate !== undefined ? parseRelativeDate(params.startDate) : endDate - defaultSpanMs;
+
+  if (startDate >= endDate) {
+    throw new Error(
+      `Invalid trace search window: startDate (${new Date(startDate).toISOString()}) must be before endDate (${new Date(endDate).toISOString()}).`,
+    );
+  }
   const format = params.format ?? "digest";
 
   const result = await apiSearchTraces({
     query: params.query,
+    traceIds: params.traceIds,
     filters: params.filters,
+    // Forwarded as itself: the filter language and the free-text query are two
+    // different searches, and the server combines them.
+    ...(params.filter ? { filter: params.filter } : {}),
     startDate,
     endDate,
     pageSize: params.pageSize ?? 25,
@@ -37,7 +174,14 @@ export async function handleSearchTraces(params: {
 
   const traces = result.traces ?? [];
   if (traces.length === 0) {
-    return "No traces found matching your query.";
+    return buildEmptyResult({
+      query: params.query,
+      traceIds: params.traceIds,
+      spanMs: endDate - startDate,
+      windowWasDefaulted: params.startDate === undefined,
+      startDate,
+      endDate,
+    });
   }
 
   if (format === "json") {
@@ -45,50 +189,20 @@ export async function handleSearchTraces(params: {
   }
 
   const lines: string[] = [];
-  lines.push(
-    `Found ${result.pagination?.totalHits ?? traces.length} traces:\n`
-  );
+  lines.push(`Found ${result.pagination?.totalHits ?? traces.length} traces:\n`);
 
   for (const trace of traces) {
-    lines.push(`### Trace: ${trace.trace_id}`);
-
-    if (trace.formatted_trace) {
-      lines.push(trace.formatted_trace);
-    } else {
-      const inputStr = trace.input?.value
-        ? String(trace.input.value)
-        : "N/A";
-      const outputStr = trace.output?.value
-        ? String(trace.output.value)
-        : "N/A";
-      lines.push(
-        `- **Input**: ${inputStr.slice(0, 100)}${inputStr.length > 100 ? "..." : ""}`
-      );
-      lines.push(
-        `- **Output**: ${outputStr.slice(0, 100)}${outputStr.length > 100 ? "..." : ""}`
-      );
-    }
-
-    if (trace.timestamps) {
-      lines.push(`- **Time**: ${trace.timestamps.started_at || "N/A"}`);
-    }
-    if (trace.error) {
-      lines.push(`- **Error**: ${JSON.stringify(trace.error)}`);
-    }
-    if (trace.evaluations && trace.evaluations.length > 0) {
-      lines.push(...formatEvaluationLines(trace.evaluations));
-    }
-    lines.push("");
+    lines.push(...traceLines(trace));
   }
 
   if (result.pagination?.scrollId) {
     lines.push(
-      `\n**More results available.** Use scrollId: "${result.pagination.scrollId}" to get next page.`
+      `\n**More results available.** Use scrollId: "${result.pagination.scrollId}" to get next page.`,
     );
   }
 
   lines.push(
-    '\n> Tip: Use `get_trace` with a trace_id for full details. Use `search_traces` with `format: "json"` for raw data. Use `discover_schema` to see available filter fields.'
+    '\n> Tip: Use `get_trace` with a traceId for full details. Use `search_traces` with `format: "json"` for raw data. Use `discover_schema` to see available filter fields.',
   );
 
   return lines.join("\n");

package/src/tools/set-model-provider.ts

@@ -1,10 +1,8 @@
-import { setModelProvider as apiSetModelProvider } from "../langwatch-api-model-providers.js";
+import { setModelProvider as apiSetModelProvider } from "../langwatch-api-model-providers.ts";
 
 /**
- * Handles the platform_set_model_provider MCP tool invocation.
- *
- * Creates or updates a model provider configuration, including API keys.
- * Returns confirmation with the updated provider status.
+ * Handles the platform_set_model_provider MCP tool: creates or updates
+ * a provider config (including API keys) and returns its status.
  */
 export async function handleSetModelProvider(params: {
   provider: string;
@@ -18,7 +16,7 @@ export async function handleSetModelProvider(params: {
 
   if (!updated) {
     throw new Error(
-      `Model provider "${params.provider}" was not found in the response. The provider name may be invalid.`
+      `Model provider "${params.provider}" was not found in the response. The provider name may be invalid.`,
     );
   }
 

package/src/tools/test-agent.ts

@@ -1,4 +1,4 @@
-import { testAgent as apiTestAgent } from "../langwatch-api-agents.js";
+import { testAgent as apiTestAgent } from "../langwatch-api-agents.ts";
 
 /**
  * Handles the platform_test_agent MCP tool invocation.
@@ -8,7 +8,7 @@ import { testAgent as apiTestAgent } from "../langwatch-api-agents.js";
 export async function handleTestAgent(params: { id: string }): Promise<string> {
   const run = await apiTestAgent(params.id);
   return [
-    "Test run scheduled. The user sends \"ping\"; the run succeeds when the agent answers.",
+    'Test run scheduled. The user sends "ping"; the run succeeds when the agent answers.',
     "",
     `**Scenario run ID:** ${run.scenarioRunId}`,
     `**Batch run ID:** ${run.batchRunId}`,

package/src/tools/update-agent.ts

@@ -1,4 +1,4 @@
-import { updateAgent as apiUpdateAgent } from "../langwatch-api-agents.js";
+import { updateAgent as apiUpdateAgent } from "../langwatch-api-agents.ts";
 
 export async function handleUpdateAgent(params: {
   id: string;

package/src/tools/update-dashboard-widget.ts

@@ -0,0 +1,86 @@
+/**
+ * `update_dashboard_widget`: the widget must sit on the named dashboard, so an agent never edits
+ * one it found elsewhere by mistake.
+ * Spec: modules/dashboard/specs/dashboard-widget-mcp.feature
+ */
+
+import type { DashboardWidget } from "../langwatch-api-dashboard-widgets.js";
+import { getWidgetOnDashboard, updateWidgetOnDashboard } from "../langwatch-api-dashboards.js";
+import { LangWatchApiError } from "../langwatch-api.js";
+import type { WidgetSource } from "../schemas/widget-sources.js";
+import {
+  type DashboardWidgetQueriesInput,
+  normalizeDashboardWidgetQueries,
+  withSources,
+} from "./dashboard-widget-queries.js";
+
+export interface UpdateDashboardWidgetParams {
+  dashboardId: string;
+  widgetId: string;
+  name?: string;
+  code?: string;
+  queries?: DashboardWidgetQueriesInput;
+  description?: string;
+  /** Set on every query; alone, it is sent with the widget's stored queries. */
+  sources?: WidgetSource[] | null;
+}
+
+export async function handleUpdateDashboardWidget(
+  params: UpdateDashboardWidgetParams,
+): Promise<string> {
+  const { dashboardId, widgetId, name, code, description, sources } = params;
+  const fields = [name, code, params.queries, description, sources];
+  if (fields.every((field) => field === undefined)) {
+    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 === undefined
+      ? undefined
+      : normalizeDashboardWidgetQueries({ queries: params.queries });
+  // Sources alone: the stored queries go back with the new list on each.
+  const base = given ?? (sources === undefined ? undefined : current.definition.queries);
+  const queries = base === undefined ? undefined : withSources({ queries: base, sources });
+
+  const changes = {
+    ...(name === undefined ? {} : { name }),
+    ...(code === undefined ? {} : { code }),
+    ...(queries === undefined ? {} : { queries }),
+    ...(description === undefined ? {} : { description }),
+  };
+
+  const widget = await updateWidgetOnDashboard({ dashboardId, widgetId: current.id, ...changes });
+
+  return [
+    `Widget "${widget.name}" updated on dashboard "${dashboardId}".`,
+    `**Widget ID**: ${widget.id}`,
+    `**Queries**: ${widget.definition.queries.map((query) => query.name).join(", ") || "(none)"}`,
+    "",
+    "```json",
+    JSON.stringify(widget, null, 2),
+    "```",
+  ].join("\n");
+}
+
+/** The widget, refused by id when it is not on this dashboard (the dashboard route answers 404). */
+async function widgetOnDashboardOrRefused({
+  widgetId,
+  dashboardId,
+}: {
+  widgetId: string;
+  dashboardId: string;
+}): Promise<DashboardWidget> {
+  try {
+    return await getWidgetOnDashboard({ dashboardId, widgetId });
+  } catch (error) {
+    if (error instanceof LangWatchApiError && error.status === 404) {
+      throw new Error(
+        `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;
+  }
+}

package/src/tools/update-dataset-record.ts

@@ -1,4 +1,4 @@
-import { updateDatasetRecord as apiUpdateDatasetRecord } from "../langwatch-api-datasets.js";
+import { updateDatasetRecord as apiUpdateDatasetRecord } from "../langwatch-api-datasets.ts";
 
 /**
  * Handles the platform_update_dataset_record MCP tool invocation.

package/src/tools/update-dataset.ts

@@ -1,12 +1,10 @@
-import { updateDataset as apiUpdateDataset } from "../langwatch-api-datasets.js";
-import type { DatasetColumnType } from "../langwatch-api-datasets.js";
-import { formatDatasetMutationDetails } from "./format-dataset-mutation.js";
+import { updateDataset as apiUpdateDataset } from "../langwatch-api-datasets.ts";
+import type { DatasetColumnType } from "../langwatch-api-datasets.ts";
+import { formatDatasetMutationDetails } from "./format-dataset-mutation.ts";
 
 /**
- * Handles the platform_update_dataset MCP tool invocation.
- *
- * Updates an existing dataset and returns a confirmation
- * with the updated details.
+ * Handles the platform_update_dataset MCP tool: updates a dataset and
+ * returns a confirmation with the updated details.
  */
 export async function handleUpdateDataset(params: {
   slugOrId: string;

package/src/tools/update-evaluator.ts

@@ -1,13 +1,11 @@
 import {
   updateEvaluator as apiUpdateEvaluator,
   getEvaluatorType,
-} from "../langwatch-api-evaluators.js";
+} from "../langwatch-api-evaluators.ts";
 
 /**
- * Handles the platform_update_evaluator MCP tool invocation.
- *
- * Updates an existing evaluator and returns a confirmation
- * with the updated details.
+ * Handles the platform_update_evaluator MCP tool: updates an evaluator
+ * and returns a confirmation with the updated details.
  */
 export async function handleUpdateEvaluator(params: {
   evaluatorId: string;

package/src/tools/update-project.ts

@@ -1,4 +1,4 @@
-import { updateProject as apiUpdateProject } from "../langwatch-api-projects.js";
+import { updateProject as apiUpdateProject } from "../langwatch-api-projects.ts";
 
 export async function handleUpdateProject(params: {
   id: string;

package/src/tools/update-prompt.ts

@@ -4,25 +4,13 @@ import {
   updatePrompt as apiUpdatePrompt,
   type PromptDetailResponse,
   type PromptTag,
-} from "../langwatch-api.js";
+} from "../langwatch-api.ts";
 
-/**
- * Handles the platform_update_prompt MCP tool invocation.
- *
- * Updates an existing prompt via the PUT endpoint. Every update with a
- * commitMessage creates a new version automatically. The mutation response
- * does not carry the tags the server actually applied, so this re-fetches
- * the prompt via getPrompt: the GET response is the prompt's latest version
- * flattened to the top level (version, versionId, commitMessage) plus a
- * `tags` array of { name, versionId } naming which version each tag points
- * to. The new version is identified by matching the request's commitMessage
- * against that top level (falling back to the versions listing), and
- * deployment state is derived from the tags that point at it — never from
- * the request's tags directly.
- */
+// Updates a prompt via PUT, creating a new version. Re-fetches the full prompt
+// to get tags since the mutation response doesn't include them.
 export async function handleUpdatePrompt(params: {
   idOrHandle: string;
-  messages?: Array<{ role: string; content: string }>;
+  messages?: { role: string; content: string }[];
   model?: string;
   commitMessage: string;
   tags?: string[];
@@ -51,10 +39,9 @@ interface IdentifiedVersion {
 }
 
 /**
- * Finds the version created by this update. The GET detail response IS the
- * latest version, so a top-level commitMessage match identifies it directly;
- * otherwise (e.g. a concurrent update landed after ours) the versions
- * listing is consulted, best-effort.
+ * Finds the version created by this update. The GET detail response IS
+ * the latest version, so a commitMessage match identifies it directly;
+ * otherwise the versions listing is consulted, best-effort.
  */
 async function identifyNewVersion({
   idOrHandle,
@@ -71,7 +58,7 @@ async function identifyNewVersion({
   try {
     const versions = await apiGetPromptVersions(idOrHandle);
     const match = (Array.isArray(versions) ? versions : []).find(
-      (v) => v.commitMessage === commitMessage
+      (v) => v.commitMessage === commitMessage,
     );
     if (match) return { version: match.version, versionId: match.versionId };
   } catch {
@@ -85,6 +72,36 @@ function deploymentTagsOf(prompt: PromptDetailResponse): PromptTag[] {
   return (prompt.tags ?? []).filter((tag) => tag?.name !== "latest");
 }
 
+function deploymentLines({
+  prompt,
+  newVersion,
+}: {
+  prompt: PromptDetailResponse;
+  newVersion: IdentifiedVersion;
+}): string[] {
+  const allDeployments = deploymentTagsOf(prompt);
+  const newTags = allDeployments
+    .filter((tag) => newVersion.versionId != null && tag.versionId === newVersion.versionId)
+    .map((tag) => tag.name);
+  if (newTags.length > 0) {
+    return [`**Deployed to**: ${newTags.join(", ")}`];
+  }
+  const lines = [`**Deployment**: not deployed`];
+
+  // Tags pointing at other versions are untouched by this update —
+  // surface them on their own line so no line pairs a version number
+  // with a deployment tag name.
+  const otherTags = Array.from(
+    new Set(
+      allDeployments.filter((tag) => tag.versionId !== newVersion.versionId).map((tag) => tag.name),
+    ),
+  );
+  if (otherTags.length > 0) {
+    lines.push(`**Existing deployments (untouched)**: ${otherTags.join(", ")}`);
+  }
+  return lines;
+}
+
 async function renderUpdateSuccess({
   idOrHandle,
   params,
@@ -109,7 +126,7 @@ async function renderUpdateSuccess({
     if (updated?.handle) lines.push(`**Handle**: ${updated.handle}`);
     lines.push(`**Commit**: ${params.commitMessage}`);
     lines.push(
-      `**Note**: the update succeeded, but version and deployment details are unavailable (confirmation read failed). Run platform_get_prompt to inspect the current state. Do not retry the update.`
+      `**Note**: the update succeeded, but version and deployment details are unavailable (confirmation read failed). Run platform_get_prompt to inspect the current state. Do not retry the update.`,
     );
     return lines.join("\n");
   }
@@ -124,10 +141,8 @@ async function renderUpdateSuccess({
   lines.push("Prompt updated successfully!\n");
   if (prompt.id) lines.push(`**ID**: ${prompt.id}`);
   if (prompt.handle) lines.push(`**Handle**: ${prompt.handle}`);
-  if (newVersion?.version != null)
-    lines.push(`**Version**: v${newVersion.version}`);
-  if (newVersion?.versionId)
-    lines.push(`**Version ID**: ${newVersion.versionId}`);
+  if (newVersion?.version != null) lines.push(`**Version**: v${newVersion.version}`);
+  if (newVersion?.versionId) lines.push(`**Version ID**: ${newVersion.versionId}`);
   lines.push(`**Commit**: ${params.commitMessage}`);
 
   if (!newVersion) {
@@ -135,40 +150,12 @@ async function renderUpdateSuccess({
     // version by commit message — say so instead of silently omitting the
     // version and deployment lines.
     lines.push(
-      `**Note**: update succeeded, but the new version could not be identified in the re-fetched prompt — version and deployment details are unavailable. Run platform_get_prompt to inspect the current state.`
+      `**Note**: update succeeded, but the new version could not be identified in the re-fetched prompt — version and deployment details are unavailable. Run platform_get_prompt to inspect the current state.`,
     );
   }
 
   if (newVersion) {
-    const allDeployments = deploymentTagsOf(prompt);
-    const newTags = allDeployments
-      .filter(
-        (tag) =>
-          newVersion.versionId != null &&
-          tag.versionId === newVersion.versionId
-      )
-      .map((tag) => tag.name);
-    if (newTags.length > 0) {
-      lines.push(`**Deployed to**: ${newTags.join(", ")}`);
-    } else {
-      lines.push(`**Deployment**: not deployed`);
-
-      // Tags pointing at other versions are untouched by this update —
-      // surface them on their own line so no line pairs a version number
-      // with a deployment tag name.
-      const otherTags = Array.from(
-        new Set(
-          allDeployments
-            .filter((tag) => tag.versionId !== newVersion.versionId)
-            .map((tag) => tag.name)
-        )
-      );
-      if (otherTags.length > 0) {
-        lines.push(
-          `**Existing deployments (untouched)**: ${otherTags.join(", ")}`
-        );
-      }
-    }
+    lines.push(...deploymentLines({ prompt, newVersion }));
   }
 
   return lines.join("\n");
@@ -203,9 +190,7 @@ async function renderTagFailure({
   if (matched) {
     const lines: string[] = [];
     lines.push("Prompt update partially failed.\n");
-    lines.push(
-      "A new version was created, but assigning the requested tag(s) failed."
-    );
+    lines.push("A new version was created, but assigning the requested tag(s) failed.");
     if (matched.versionId) lines.push(`**Version ID**: ${matched.versionId}`);
     lines.push(`**Status**: created, untagged`);
     lines.push(`**Failed tag(s)**: ${failedTags}`);

package/src/tools/update-scenario.ts

@@ -1,12 +1,10 @@
-import { updateScenario as apiUpdateScenario } from "../langwatch-api-scenarios.js";
-import type { ScenarioFieldValues } from "../schemas/suite-fields.js";
-import { formatScenarioFields } from "./format-scenario.js";
+import { updateScenario as apiUpdateScenario } from "../langwatch-api-scenarios.ts";
+import type { ScenarioFieldValues } from "../schemas/suite-fields.ts";
+import { formatScenarioFields } from "./format-scenario.ts";
 
 /**
- * Handles the platform_update_scenario MCP tool invocation.
- *
- * Updates an existing scenario and returns a confirmation
- * with the updated details.
+ * Handles the platform_update_scenario MCP tool: updates a scenario and
+ * returns a confirmation with the updated details.
  */
 export async function handleUpdateScenario(params: {
   scenarioId: string;

package/src/tools/update-test-suite.ts

@@ -1,20 +1,15 @@
-import { updateTestSuite as apiUpdateTestSuite } from "../langwatch-api-test-suites.js";
+import { updateTestSuite as apiUpdateTestSuite } from "../langwatch-api-test-suites.ts";
 import {
   type EvaluatorAttachmentInput,
   type SuiteField,
   toWireAttachments,
-} from "../schemas/suite-fields.js";
-import {
-  formatEvaluatorAttachments,
-  formatSuiteFields,
-} from "./format-suite-details.js";
+} from "../schemas/suite-fields.ts";
+import { formatEvaluatorAttachments, formatSuiteFields } from "./format-suite-details.ts";
 
 /**
- * Handles the platform_update_test_suite MCP tool invocation.
- *
- * Any of the name, the fields and the evaluators. A field list or an
- * evaluator list replaces the one the suite holds; a key left out keeps
- * what the suite has.
+ * Handles the platform_update_test_suite MCP tool: updates any of name,
+ * fields and evaluators. A field or evaluator list replaces what the
+ * suite holds; a key left out keeps its current value.
  */
 export async function handleUpdateTestSuite(params: {
   id: string;

package/src/utils/date-parsing.ts

@@ -24,7 +24,7 @@ export function parseRelativeDate(input: string): number {
   const parsed = Date.parse(input);
   if (Number.isNaN(parsed)) {
     throw new Error(
-      `Invalid date: "${input}". Use a relative duration (e.g. "24h", "7d", "4w") or an ISO date string.`
+      `Invalid date: "${input}". Use a relative duration (e.g. "24h", "7d", "4w") or an ISO date string.`,
     );
   }
   return parsed;

package/src/utils/escape-markdown.ts

@@ -1,12 +1,7 @@
 /**
- * Escapes characters that would break markdown table formatting.
- *
- * Replaces pipe characters (`|`) with `\|` and newlines with spaces
- * so that values can be safely embedded in markdown tables and headers.
+ * Escapes characters that would break markdown table formatting:
+ * replaces `|` with `\|` and newlines with spaces.
  */
 export function escapeMarkdown(value: string): string {
-  return value
-    .replace(/\\/g, "\\\\")
-    .replace(/\|/g, "\\|")
-    .replace(/\n/g, " ");
+  return value.replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\n/g, " ");
 }