@langwatch/mcp-server 2.0.0 → 2.2.0

package/src/tools/list-prompts.ts

@@ -1,10 +1,8 @@
-import { listPrompts as apiListPrompts } from "../langwatch-api.js";
+import { listPrompts as apiListPrompts } from "../langwatch-api.ts";
 
 /**
- * Handles the platform_list_prompts MCP tool invocation.
- *
- * Lists all prompts in the LangWatch project, formatted as an
- * AI-readable markdown table.
+ * Handles the platform_list_prompts MCP tool: lists prompts in the
+ * project as an AI-readable markdown table.
  */
 export async function handleListPrompts(): Promise<string> {
   const prompts = await apiListPrompts();
@@ -26,9 +24,7 @@ export async function handleListPrompts(): Promise<string> {
     lines.push(`| ${handle} | ${name} | ${version} |`);
   }
 
-  lines.push(
-    "\n> Use `platform_get_prompt` with the handle or ID to see full prompt details."
-  );
+  lines.push("\n> Use `platform_get_prompt` with the handle or ID to see full prompt details.");
 
   return lines.join("\n");
 }

package/src/tools/list-run-plans.ts

@@ -0,0 +1,47 @@
+import { listRunPlans as apiListRunPlans } from "../langwatch-api-run-plans.ts";
+import { describeRunPlanScope } from "./format-run-plan.ts";
+
+/**
+ * Handles the platform_list_run_plans MCP tool invocation.
+ */
+export async function handleListRunPlans(params: {
+  includeArchived?: boolean;
+  format?: "digest" | "json";
+}): Promise<string> {
+  const plans = await apiListRunPlans({
+    includeArchived: params.includeArchived,
+  });
+
+  if (params.format === "json") {
+    return JSON.stringify(plans, null, 2);
+  }
+
+  if (!Array.isArray(plans) || plans.length === 0) {
+    return "No run plans found in this project.\n\n> Tip: Use `platform_run_plan` to start one. A run plan is created the first time you run its name.";
+  }
+
+  const lines: string[] = [];
+  lines.push(`# Run Plans (${plans.length} total)\n`);
+
+  for (const plan of plans) {
+    lines.push(`## ${plan.name}${plan.archivedAt ? " (archived)" : ""}`);
+    lines.push(`**ID**: ${plan.id}`);
+    lines.push(`**Covers**: ${describeRunPlanScope(plan.scope, plan.scenarioIds)}`);
+    lines.push(
+      `**Targets**: ${plan.targets.length} (${plan.targets
+        .map((t) => `${t.type}:${t.referenceId}`)
+        .join(", ")})`,
+    );
+    lines.push(`**Repeat**: ${plan.repeatCount}x`);
+    if (plan.labels.length > 0) {
+      lines.push(`**Labels**: ${plan.labels.join(", ")}`);
+    }
+    lines.push("");
+  }
+
+  lines.push(
+    "> Use `platform_get_run_plan` with the ID for the full configuration, or `platform_rerun_run_plan` to run it again.",
+  );
+
+  return lines.join("\n");
+}

package/src/tools/list-scenarios.ts

@@ -1,22 +1,30 @@
-import { listScenarios as apiListScenarios } from "../langwatch-api-scenarios.js";
+import { listScenarios as apiListScenarios } from "../langwatch-api-scenarios.ts";
 
 /**
- * Handles the platform_list_scenarios MCP tool invocation.
- *
- * Lists all scenarios in the LangWatch project, formatted as an
- * AI-readable digest or raw JSON.
+ * Handles the platform_list_scenarios MCP tool: lists scenarios in the
+ * project as an AI-readable digest or raw JSON.
  */
 export async function handleListScenarios(params: {
+  testSuiteId?: string;
   format?: "digest" | "json";
 }): Promise<string> {
-  const scenarios = await apiListScenarios();
+  const all = await apiListScenarios();
+
+  // The REST list takes no test suite query, so the filter runs here on the
+  // testSuiteId every scenario already carries in the response.
+  const scenarios =
+    params.testSuiteId !== undefined && Array.isArray(all)
+      ? all.filter((s) => s.testSuiteId === params.testSuiteId)
+      : all;
 
   if (params.format === "json") {
     return JSON.stringify(scenarios, null, 2);
   }
 
   if (!Array.isArray(scenarios) || scenarios.length === 0) {
-    return "No scenarios found in this project.\n\n> Tip: Use `platform_create_scenario` to create your first scenario.";
+    return params.testSuiteId !== undefined
+      ? `No scenarios found in test suite ${params.testSuiteId}.\n\n> Tip: Use \`platform_create_scenario\` with testSuiteId \`${params.testSuiteId}\` to file one there.`
+      : "No scenarios found in this project.\n\n> Tip: Use `platform_create_scenario` to create your first scenario.";
   }
 
   const lines: string[] = [];
@@ -25,23 +33,24 @@ export async function handleListScenarios(params: {
   for (const s of scenarios) {
     lines.push(`## ${s.name}`);
     lines.push(`**ID**: ${s.id}`);
-    const preview =
-      s.situation && s.situation.length > 60
-        ? s.situation.slice(0, 60) + "..."
-        : s.situation;
+    const preview = formatSituationPreview(s.situation);
     lines.push(`**Situation**: ${preview}`);
-    lines.push(
-      `**Criteria**: ${Array.isArray(s.criteria) ? s.criteria.length : 0} criteria`,
-    );
+    lines.push(`**Criteria**: ${Array.isArray(s.criteria) ? s.criteria.length : 0} criteria`);
     if (Array.isArray(s.labels) && s.labels.length > 0) {
       lines.push(`**Labels**: ${s.labels.join(", ")}`);
     }
     lines.push("");
   }
 
-  lines.push(
-    "> Use `platform_get_scenario` with the ID to see full scenario details.",
-  );
+  lines.push("> Use `platform_get_scenario` with the ID to see full scenario details.");
 
   return lines.join("\n");
 }
+
+function formatSituationPreview(situation: string | undefined): string | undefined {
+  if (situation && situation.length > 60) {
+    return situation.slice(0, 60) + "...";
+  }
+
+  return situation;
+}

package/src/tools/list-simulation-runs.ts

@@ -1,4 +1,5 @@
-import { listSimulationRuns as apiListSimulationRuns } from "../langwatch-api-simulation-runs.js";
+import { listSimulationRuns as apiListSimulationRuns } from "../langwatch-api-simulation-runs.ts";
+import { formatRunStatus } from "./format-suite-details.ts";
 
 /**
  * Handles the platform_list_simulation_runs MCP tool invocation.
@@ -22,14 +23,16 @@ export async function handleListSimulationRuns(params: {
   const { runs } = result;
 
   if (runs.length === 0) {
-    return "No simulation runs found.\n\n> Run a suite first with `platform_run_suite` to create simulation runs.";
+    return "No simulation runs found.\n\n> Run scenarios first with `platform_run_plan` or `platform_run_test_suite` to create simulation runs.";
   }
 
   const lines: string[] = [];
-  lines.push(`# Simulation Runs (${runs.length} results${result.hasMore ? ", more available" : ""})\n`);
+  lines.push(
+    `# Simulation Runs (${runs.length} results${result.hasMore ? ", more available" : ""})\n`,
+  );
 
   for (const run of runs) {
-    const statusIcon = run.status === "SUCCESS" ? "pass" : run.status === "FAILED" ? "FAIL" : run.status;
+    const statusIcon = formatRunStatus(run.status);
     const duration = run.durationInMs > 0 ? `${(run.durationInMs / 1000).toFixed(1)}s` : "—";
     const verdict = run.results?.verdict ?? "";
 
@@ -40,10 +43,15 @@ export async function handleListSimulationRuns(params: {
     if (run.totalCost) {
       lines.push(`**Cost**: $${run.totalCost.toFixed(4)}`);
     }
+    if (run.note) {
+      lines.push(`**Note**: ${run.note}`);
+    }
     lines.push("");
   }
 
-  lines.push("> Use `platform_get_simulation_run` with a run ID to see full details (messages, results).");
+  lines.push(
+    "> Use `platform_get_simulation_run` with a run ID to see full details (messages, results).",
+  );
 
   return lines.join("\n");
 }

package/src/tools/list-test-suites.ts

@@ -0,0 +1,35 @@
+import { listTestSuites as apiListTestSuites } from "../langwatch-api-test-suites.ts";
+
+/**
+ * Handles the platform_list_test_suites MCP tool invocation.
+ */
+export async function handleListTestSuites(params: {
+  format?: "digest" | "json";
+}): Promise<string> {
+  const suites = await apiListTestSuites();
+
+  if (params.format === "json") {
+    return JSON.stringify(suites, null, 2);
+  }
+
+  if (!Array.isArray(suites) || suites.length === 0) {
+    return "No test suites found in this project.\n\n> Tip: Use `platform_create_test_suite` to create one, then file scenarios in it with `testSuiteId`.";
+  }
+
+  const lines: string[] = [];
+  lines.push(`# Test Suites (${suites.length} total)\n`);
+
+  for (const suite of suites) {
+    lines.push(`## ${suite.name}${suite.archivedAt ? " (archived)" : ""}`);
+    lines.push(`**ID**: ${suite.id}`);
+    lines.push(`**Slug**: ${suite.slug}`);
+    lines.push(`**Scenarios**: ${suite.scenarioCount}`);
+    lines.push("");
+  }
+
+  lines.push(
+    "> Use `platform_get_test_suite` with the ID to read the scenarios, or `platform_run_test_suite` to run them against a target.",
+  );
+
+  return lines.join("\n");
+}

package/src/tools/list-trigger-fires.ts

@@ -0,0 +1,17 @@
+import { listTriggerFires as apiListTriggerFires } from "../langwatch-api-triggers.ts";
+
+/**
+ * Handles the platform_list_trigger_fires MCP tool invocation: one page of
+ * fires, newest first, and the cursor for the next page when there is one.
+ */
+export async function handleListTriggerFires(params: {
+  id: string;
+  limit?: number;
+  cursor?: string;
+}): Promise<string> {
+  const page = await apiListTriggerFires(params);
+  if (page.fires.length === 0) {
+    return params.cursor ? "No more fires." : "This automation has not fired yet.";
+  }
+  return JSON.stringify(page, null, 2);
+}

package/src/tools/list-triggers.ts

@@ -0,0 +1,39 @@
+import { listTriggers as apiListTriggers } from "../langwatch-api-triggers.ts";
+import type { Trigger } from "../schemas/triggers.ts";
+
+/**
+ * Handles the platform_list_triggers MCP tool invocation.
+ */
+export async function handleListTriggers(params: { format?: "digest" | "json" }): Promise<string> {
+  const triggers = await apiListTriggers();
+  if (params.format === "json") return JSON.stringify(triggers, null, 2);
+  if (triggers.length === 0) {
+    return "No triggers found. Use `platform_create_trigger` to create one.";
+  }
+  const lines = [`# Triggers (${triggers.length} total)\n`];
+  for (const trigger of triggers) lines.push(...digestTrigger(trigger), "");
+  return lines.join("\n");
+}
+
+function digestTrigger(trigger: Trigger): string[] {
+  const lines = [
+    `## ${trigger.name}`,
+    `**ID**: ${trigger.id}`,
+    `**Kind**: ${trigger.kind ?? "AUTOMATION"}`,
+    `**Action**: ${trigger.action}`,
+    `**Status**: ${trigger.active ? "active" : "inactive"}`,
+  ];
+  if (trigger.alertType) lines.push(`**Alert**: ${trigger.alertType}`);
+  if (trigger.filterQuery) lines.push(`**Filter query**: ${trigger.filterQuery}`);
+  else if (Object.keys(trigger.filters).length > 0) {
+    lines.push(`**Filters**: ${JSON.stringify(trigger.filters)}`);
+  }
+  if (trigger.graphAlert) {
+    const rule = trigger.graphAlert;
+    lines.push(
+      `**Fires when**: ${rule.seriesName} ${rule.operator} ${rule.threshold} over ${rule.timePeriod}m${trigger.customGraphId ? ` on graph ${trigger.customGraphId}` : ""}`,
+    );
+  }
+  if (trigger.report) lines.push(`**Report**: ${JSON.stringify(trigger.report)}`);
+  return lines;
+}

package/src/tools/list-workflows.ts

@@ -1,4 +1,4 @@
-import { listWorkflows as apiListWorkflows } from "../langwatch-api-workflows.js";
+import { listWorkflows as apiListWorkflows } from "../langwatch-api-workflows.ts";
 
 export async function handleListWorkflows(): Promise<string> {
   const workflows = await apiListWorkflows();
@@ -23,9 +23,7 @@ export async function handleListWorkflows(): Promise<string> {
     lines.push("");
   }
 
-  lines.push(
-    "> Use `platform_get_workflow` with the ID to see full workflow details.",
-  );
+  lines.push("> Use `platform_get_workflow` with the ID to see full workflow details.");
 
   return lines.join("\n");
 }

package/src/tools/rename-prompt-tag.ts

@@ -1,4 +1,4 @@
-import { renamePromptTag as apiRenamePromptTag } from "../langwatch-api.js";
+import { renamePromptTag as apiRenamePromptTag } from "../langwatch-api.ts";
 
 export async function handleRenamePromptTag(params: {
   tag: string;

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

@@ -0,0 +1,15 @@
+import { renameTestSuite as apiRenameTestSuite } from "../langwatch-api-test-suites.ts";
+
+/**
+ * Handles the platform_rename_test_suite MCP tool invocation.
+ */
+export async function handleRenameTestSuite(params: { id: string; name: string }): Promise<string> {
+  const suite = await apiRenameTestSuite(params);
+
+  return [
+    `Test suite ${suite.id} is now named "${suite.name}".`,
+    "",
+    `**Slug**: ${suite.slug}`,
+    `**Scenarios**: ${suite.scenarioCount}`,
+  ].join("\n");
+}

package/src/tools/report-issue.ts

@@ -5,7 +5,8 @@ import {
   redactSessionJsonl,
   truncateJsonlToByteBudget,
 } from "@langwatch/redaction";
-import { getConfig } from "../config.js";
+
+import { getConfig } from "../config.ts";
 
 /** Transcripts are capped after redaction; oldest lines are dropped first. */
 const MAX_SESSION_BYTES = 8 * 1024 * 1024;
@@ -68,14 +69,11 @@ function redactReport(params: ReportIssueParams): RedactedReport {
   };
 }
 
-async function deliverReport(
-  report: RedactedReport,
-  params: ReportIssueParams,
-): Promise<string> {
+async function deliverReport(report: RedactedReport, params: ReportIssueParams): Promise<string> {
   const config = getConfig();
   const endpoint = config.endpoint.replace(/\/+$/, "");
 
-  const response = await fetch(`${endpoint}/api/bug-reports`, {
+  const response = await fetch(`${endpoint}/api/v1/bug-reports`, {
     method: "POST",
     headers: {
       "content-type": "application/json",
@@ -117,9 +115,7 @@ async function deliverReport(
  * an API key: the reporter may be struggling precisely because setup failed.
  * When a key is configured it only links the report to the project.
  */
-export async function handleReportIssue(
-  params: ReportIssueParams,
-): Promise<string> {
+export async function handleReportIssue(params: ReportIssueParams): Promise<string> {
   if (!params.user_approved) {
     throw new Error(
       "This sends a report to the LangWatch team, so the user must approve it first. " +

package/src/tools/rerun-run-plan.ts

@@ -0,0 +1,18 @@
+import { rerunRunPlan as apiRerunRunPlan, type RunParameters } from "../langwatch-api-run-plans.ts";
+import { formatRunPlanRun } from "./format-run-plan.ts";
+
+/**
+ * Handles the platform_rerun_run_plan MCP tool invocation.
+ */
+export async function handleRerunRunPlan(params: {
+  id: string;
+  parameters?: RunParameters;
+  note?: string;
+}): Promise<string> {
+  const result = await apiRerunRunPlan(params.id, {
+    parameters: params.parameters,
+    note: params.note,
+  });
+
+  return formatRunPlanRun(result);
+}

package/src/tools/revoke-api-key.ts

@@ -1,8 +1,6 @@
-import { revokeApiKey as apiRevokeApiKey } from "../langwatch-api-api-keys.js";
+import { revokeApiKey as apiRevokeApiKey } from "../langwatch-api-api-keys.ts";
 
-export async function handleRevokeApiKey(params: {
-  id: string;
-}): Promise<string> {
+export async function handleRevokeApiKey(params: { id: string }): Promise<string> {
   await apiRevokeApiKey(params.id);
 
   return `API key ${params.id} revoked successfully.`;

package/src/tools/run-agent.ts

@@ -1,35 +1,86 @@
-import { runAgent as apiRunAgent } from "../langwatch-api-agents.js";
+import { z } from "zod";
+
+import { runAgent as apiRunAgent, type AgentCallParams } from "../langwatch-api-agents.ts";
+
+/**
+ * A scalar and an array both parse as JSON, and either one reaches the agent
+ * as a body it cannot read, so only an object passes.
+ */
+const jsonObjectSchema = z.looseObject({});
+type JsonObject = z.infer<typeof jsonObjectSchema>;
+
+function outputLines(result: object): string[] {
+  const output = (result as Record<string, unknown>).output;
+  if (output !== undefined) {
+    return ["**Output:**", typeof output === "string" ? output : JSON.stringify(output, null, 2)];
+  }
+  return ["**Result:**", JSON.stringify(result, null, 2)];
+}
+
+function connectedLines(result: object): string[] {
+  const lines: string[] = [];
+  const instance = (result as { instance?: { hostname?: string; label?: string | null } }).instance;
+  const durationMs = (result as { durationMs?: number }).durationMs;
+  if (instance?.hostname) {
+    const label = instance.label ? ` (${instance.label})` : "";
+    lines.push(`\n**Instance:** ${instance.hostname}${label}`);
+  }
+  if (typeof durationMs === "number") lines.push(`**Duration:** ${durationMs} ms`);
+  const session = (result as { session?: unknown }).session;
+  if (session !== undefined && session !== null) {
+    lines.push("**Session:**");
+    lines.push(JSON.stringify(session, null, 2));
+  }
+  return lines;
+}
 
 /**
  * Handles the platform_run_agent MCP tool invocation.
+ *
+ * @see specs/mcp-server/agent-tools.feature
  */
-export async function handleRunAgent(params: {
+export async function handleRunAgent({
+  id,
+  input,
+  message,
+  parameters,
+  threadId,
+}: {
   id: string;
   input?: string;
+  message?: string;
+  parameters?: AgentCallParams;
+  threadId?: string;
 }): Promise<string> {
-  let parsedInput: Record<string, unknown> = {};
-  if (params.input) {
+  let parsedInput: JsonObject = {};
+  if (input) {
+    let decoded: unknown;
     try {
-      parsedInput = JSON.parse(params.input) as Record<string, unknown>;
+      decoded = JSON.parse(input);
     } catch {
       return "Error: `input` must be a valid JSON object.";
     }
+    const result = jsonObjectSchema.safeParse(decoded);
+    if (!result.success) {
+      return "Error: `input` must be a valid JSON object.";
+    }
+    parsedInput = result.data;
   }
 
-  const { agentType, result } = await apiRunAgent(params.id, parsedInput);
+  const { agentType, result } = await apiRunAgent({
+    id,
+    input: parsedInput,
+    message,
+    parameters,
+    threadId,
+  });
 
   const lines: string[] = [];
   lines.push(`Agent executed successfully (type: ${agentType}).\n`);
 
   if (typeof result === "object" && result !== null) {
-    const output = (result as Record<string, unknown>).output;
-    if (output !== undefined) {
-      lines.push("**Output:**");
-      lines.push(typeof output === "string" ? output : JSON.stringify(output, null, 2));
-    } else {
-      lines.push("**Result:**");
-      lines.push(JSON.stringify(result, null, 2));
-    }
+    lines.push(...outputLines(result));
+    if (agentType === "connected") lines.push(...connectedLines(result));
   }
 
   return lines.join("\n");

package/src/tools/run-experiment.ts

@@ -1,5 +1,5 @@
-import { LangWatchApiError, makeRequest } from "../langwatch-api.js";
-import { deriveRunStatus } from "./experiment-run-status.js";
+import { LangWatchApiError, makeRequest } from "../langwatch-api.ts";
+import { deriveRunStatus } from "./experiment-run-status.ts";
 
 interface EvaluationRunResponse {
   runId: string;
@@ -24,12 +24,10 @@ interface EvaluationStatusResponse {
   };
 }
 
-export async function handleRunExperiment(params: {
-  slug: string;
-}): Promise<string> {
+export async function handleRunExperiment(params: { slug: string }): Promise<string> {
   const result = (await makeRequest(
     "POST",
-    `/api/experiments/${encodeURIComponent(params.slug)}/run`,
+    `/api/v1/experiments/${encodeURIComponent(params.slug)}/run`,
   )) as EvaluationRunResponse;
 
   const lines: string[] = [];
@@ -75,7 +73,7 @@ async function statusFromResults(params: {
   try {
     results = (await makeRequest(
       "GET",
-      `/api/experiments/runs/${encodeURIComponent(params.runId)}/results${qs}`,
+      `/api/v1/experiments/runs/${encodeURIComponent(params.runId)}/results${qs}`,
     )) as ResultsForStatus;
   } catch (error) {
     // Only a genuine "no such run" is a fallback miss (-> guidance). Real
@@ -97,19 +95,13 @@ async function statusFromResults(params: {
   lines.push(`**Status**: ${status}`);
   lines.push(`**Progress**: ${progress}/${total} cells`);
   if (results.timestamps.createdAt) {
-    lines.push(
-      `**Started**: ${new Date(results.timestamps.createdAt).toISOString()}`,
-    );
+    lines.push(`**Started**: ${new Date(results.timestamps.createdAt).toISOString()}`);
   }
   if (results.timestamps.finishedAt) {
-    lines.push(
-      `**Finished**: ${new Date(results.timestamps.finishedAt).toISOString()}`,
-    );
+    lines.push(`**Finished**: ${new Date(results.timestamps.finishedAt).toISOString()}`);
   }
   if (results.timestamps.stoppedAt) {
-    lines.push(
-      `**Stopped**: ${new Date(results.timestamps.stoppedAt).toISOString()}`,
-    );
+    lines.push(`**Stopped**: ${new Date(results.timestamps.stoppedAt).toISOString()}`);
   }
   lines.push("");
   lines.push(
@@ -118,6 +110,31 @@ async function statusFromResults(params: {
   return lines.join("\n");
 }
 
+async function statusAfterFailedRead({
+  params,
+  error,
+}: {
+  params: { runId: string; experimentSlug?: string };
+  error: unknown;
+}): Promise<string> {
+  const code = error instanceof LangWatchApiError ? error.status : undefined;
+  const message = error instanceof Error ? error.message : String(error);
+  if (code === 404 || /404|not found/i.test(message)) {
+    const fallback = await statusFromResults(params);
+    if (fallback) return fallback;
+    return [
+      `# Evaluation Run ${params.runId}`,
+      "",
+      "**Status**: not found",
+      "",
+      `Could not find run \`${params.runId}\`. SDK-logged runs and runs older than 24h are not in the live run-state and must be resolved by experiment slug.`,
+      "",
+      "> Pass `experimentSlug`: discover it with `platform_experiment_list`, then use `platform_experiment_list_runs` for the run ids. Or fetch the rows directly with `platform_experiment_results`.",
+    ].join("\n");
+  }
+  throw error;
+}
+
 export async function handleExperimentStatus(params: {
   runId: string;
   experimentSlug?: string;
@@ -126,26 +143,10 @@ export async function handleExperimentStatus(params: {
   try {
     status = (await makeRequest(
       "GET",
-      `/api/experiments/runs/${encodeURIComponent(params.runId)}`,
+      `/api/v1/experiments/runs/${encodeURIComponent(params.runId)}`,
     )) as EvaluationStatusResponse;
   } catch (error) {
-    const code =
-      error instanceof LangWatchApiError ? error.status : undefined;
-    const message = error instanceof Error ? error.message : String(error);
-    if (code === 404 || /404|not found/i.test(message)) {
-      const fallback = await statusFromResults(params);
-      if (fallback) return fallback;
-      return [
-        `# Evaluation Run ${params.runId}`,
-        "",
-        "**Status**: not found",
-        "",
-        `Could not find run \`${params.runId}\`. SDK-logged runs and runs older than 24h are not in the live run-state and must be resolved by experiment slug.`,
-        "",
-        "> Pass `experimentSlug`: discover it with `platform_experiment_list`, then use `platform_experiment_list_runs` for the run ids. Or fetch the rows directly with `platform_experiment_results`.",
-      ].join("\n");
-    }
-    throw error;
+    return statusAfterFailedRead({ params, error });
   }
 
   const lines: string[] = [];
@@ -169,9 +170,7 @@ export async function handleExperimentStatus(params: {
       lines.push(`**Failed**: ${status.summary.failedCells}`);
     }
     if (status.summary.duration) {
-      lines.push(
-        `**Duration**: ${(status.summary.duration / 1000).toFixed(1)}s`,
-      );
+      lines.push(`**Duration**: ${(status.summary.duration / 1000).toFixed(1)}s`);
     }
     if (status.summary.runUrl) {
       lines.push(`**View results**: ${status.summary.runUrl}`);

package/src/tools/run-plan.ts

@@ -0,0 +1,46 @@
+import {
+  runRunPlan as apiRunRunPlan,
+  type RunParameters,
+  type RunPlanScope,
+  type RunPlanTarget,
+} from "../langwatch-api-run-plans.ts";
+import { toWireTargets } from "../schemas/run-plan.ts";
+import { type EvaluatorAttachmentInput, toWireAttachments } from "../schemas/suite-fields.ts";
+import { formatRunPlanRun } from "./format-run-plan.ts";
+
+/**
+ * Handles the platform_run_plan MCP tool invocation.
+ */
+export async function handleRunPlan(params: {
+  name?: string;
+  scope: RunPlanScope;
+  scenarioIds?: string[];
+  targets: RunPlanTarget[];
+  repeatCount?: number;
+  simulatorModel?: string;
+  judgeModel?: string;
+  evaluators?: EvaluatorAttachmentInput[];
+  parameters?: RunParameters;
+  note?: string;
+  idempotencyKey?: string;
+}): Promise<string> {
+  const result = await apiRunRunPlan({
+    name: params.name,
+    config: {
+      scope: params.scope,
+      targets: toWireTargets(params.targets),
+      repeatCount: params.repeatCount,
+      simulatorModel: params.simulatorModel,
+      judgeModel: params.judgeModel,
+      scenarioIds: params.scenarioIds,
+      ...(params.evaluators !== undefined
+        ? { evaluators: toWireAttachments(params.evaluators) }
+        : {}),
+    },
+    idempotencyKey: params.idempotencyKey,
+    parameters: params.parameters,
+    note: params.note,
+  });
+
+  return formatRunPlanRun(result);
+}