@langwatch/mcp-server 2.0.0 → 2.2.0

package/src/tools/update-prompt.ts

@@ -1,31 +1,201 @@
-import { updatePrompt as apiUpdatePrompt } from "../langwatch-api.js";
+import {
+  getPrompt as apiGetPrompt,
+  getPromptVersions as apiGetPromptVersions,
+  updatePrompt as apiUpdatePrompt,
+  type PromptDetailResponse,
+  type PromptTag,
+} 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.
- */
+// 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[];
 }): Promise<string> {
   const { idOrHandle, ...data } = params;
 
-  const result = await apiUpdatePrompt(idOrHandle, data);
+  let updated;
+  try {
+    updated = await apiUpdatePrompt(idOrHandle, data);
+  } catch (err) {
+    // The platform commits the version before assigning tags, so a
+    // rejection while tags were requested may still have created a version.
+    // Re-fetch to find out rather than reporting a bare failure.
+    if (params.tags && params.tags.length > 0) {
+      return renderTagFailure({ idOrHandle, params });
+    }
+    throw err;
+  }
+
+  return renderUpdateSuccess({ idOrHandle, params, updated });
+}
+
+interface IdentifiedVersion {
+  version?: number;
+  versionId?: string;
+}
+
+/**
+ * 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,
+  prompt,
+  commitMessage,
+}: {
+  idOrHandle: string;
+  prompt: PromptDetailResponse;
+  commitMessage: string;
+}): Promise<IdentifiedVersion | undefined> {
+  if (prompt.commitMessage === commitMessage) {
+    return { version: prompt.version, versionId: prompt.versionId };
+  }
+  try {
+    const versions = await apiGetPromptVersions(idOrHandle);
+    const match = (Array.isArray(versions) ? versions : []).find(
+      (v) => v.commitMessage === commitMessage,
+    );
+    if (match) return { version: match.version, versionId: match.versionId };
+  } catch {
+    // Identification failure is reported by the caller.
+  }
+  return undefined;
+}
+
+/** The prompt's deployment tags, excluding the built-in "latest" tag. */
+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,
+  updated,
+}: {
+  idOrHandle: string;
+  params: { commitMessage: string; tags?: string[] };
+  updated?: { id?: string; handle?: string };
+}): Promise<string> {
+  let prompt;
+  try {
+    prompt = await apiGetPrompt(idOrHandle, {
+      version: undefined,
+      tag: undefined,
+    });
+  } catch {
+    // The update itself succeeded; a failed confirmation read must not
+    // surface as a tool failure — that invites a dangerous retry.
+    const lines: string[] = [];
+    lines.push("Prompt updated successfully!\n");
+    if (updated?.id) lines.push(`**ID**: ${updated.id}`);
+    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.`,
+    );
+    return lines.join("\n");
+  }
+
+  const newVersion = await identifyNewVersion({
+    idOrHandle,
+    prompt,
+    commitMessage: params.commitMessage,
+  });
 
   const lines: string[] = [];
   lines.push("Prompt updated successfully!\n");
-  if (result.id) lines.push(`**ID**: ${result.id}`);
-  if (result.handle) lines.push(`**Handle**: ${result.handle}`);
-  if (result.latestVersionNumber != null)
-    lines.push(`**Version**: v${result.latestVersionNumber}`);
+  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}`);
   lines.push(`**Commit**: ${params.commitMessage}`);
-  if (params.tags && params.tags.length > 0)
-    lines.push(`**Tags**: ${params.tags.join(", ")}`);
+
+  if (!newVersion) {
+    // The update succeeded but the re-fetch could not identify the new
+    // 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.`,
+    );
+  }
+
+  if (newVersion) {
+    lines.push(...deploymentLines({ prompt, newVersion }));
+  }
 
   return lines.join("\n");
 }
+
+async function renderTagFailure({
+  idOrHandle,
+  params,
+}: {
+  idOrHandle: string;
+  params: { commitMessage: string; tags?: string[] };
+}): Promise<string> {
+  const failedTags = params.tags?.join(", ") ?? "";
+  let prompt;
+  try {
+    prompt = await apiGetPrompt(idOrHandle, {
+      version: undefined,
+      tag: undefined,
+    });
+  } catch {
+    // The confirmation read failed too — report the tag-assignment failure
+    // without claiming whether a version was created.
+    return `Prompt update failed: could not assign tag(s) ${failedTags} to "${idOrHandle}". Whether a new version was created could not be confirmed (confirmation read failed) — run platform_get_prompt before retrying.`;
+  }
+
+  const matched = await identifyNewVersion({
+    idOrHandle,
+    prompt,
+    commitMessage: params.commitMessage,
+  });
+
+  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.");
+    if (matched.versionId) lines.push(`**Version ID**: ${matched.versionId}`);
+    lines.push(`**Status**: created, untagged`);
+    lines.push(`**Failed tag(s)**: ${failedTags}`);
+    return lines.join("\n");
+  }
+
+  return `Prompt update failed: could not assign tag(s) ${failedTags} to "${idOrHandle}".`;
+}

package/src/tools/update-scenario.ts

@@ -1,10 +1,10 @@
-import { updateScenario as apiUpdateScenario } from "../langwatch-api-scenarios.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;
@@ -12,6 +12,8 @@ export async function handleUpdateScenario(params: {
   situation?: string;
   criteria?: string[];
   labels?: string[];
+  testSuiteId?: string | null;
+  fields?: ScenarioFieldValues;
 }): Promise<string> {
   const { scenarioId, ...data } = params;
   const result = await apiUpdateScenario({ id: scenarioId, ...data });
@@ -27,6 +29,10 @@ export async function handleUpdateScenario(params: {
   if (Array.isArray(result.labels) && result.labels.length > 0) {
     lines.push(`**Labels**: ${result.labels.join(", ")}`);
   }
+  if (result.testSuiteId) {
+    lines.push(`**Test suite**: ${result.testSuiteId}`);
+  }
+  lines.push(...formatScenarioFields(result.fields));
 
   return lines.join("\n");
 }

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

@@ -0,0 +1,40 @@
+import { updateTestSuite as apiUpdateTestSuite } from "../langwatch-api-test-suites.ts";
+import {
+  type EvaluatorAttachmentInput,
+  type SuiteField,
+  toWireAttachments,
+} from "../schemas/suite-fields.ts";
+import { formatEvaluatorAttachments, formatSuiteFields } from "./format-suite-details.ts";
+
+/**
+ * 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;
+  name?: string;
+  fields?: SuiteField[];
+  evaluators?: EvaluatorAttachmentInput[];
+}): Promise<string> {
+  const suite = await apiUpdateTestSuite({
+    id: params.id,
+    ...(params.name !== undefined ? { name: params.name } : {}),
+    ...(params.fields !== undefined ? { fields: params.fields } : {}),
+    ...(params.evaluators !== undefined
+      ? { evaluators: toWireAttachments(params.evaluators) }
+      : {}),
+  });
+
+  return [
+    `Test suite "${suite.name}" updated.`,
+    "",
+    `**ID**: ${suite.id}`,
+    `**Slug**: ${suite.slug}`,
+    `**Scenarios**: ${suite.scenarioCount}`,
+    ...formatSuiteFields(suite.fields),
+    ...formatEvaluatorAttachments(suite.evaluators),
+    "",
+    `**View**: ${suite.platformUrl}`,
+  ].join("\n");
+}

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, " ");
 }

package/src/utils/format-evaluations.ts

@@ -9,12 +9,12 @@ export interface EvaluationSummary {
 /** Formats a trace's evaluation results as markdown bullet lines, one per evaluation. */
 export function formatEvaluationLines(evaluations: EvaluationSummary[]): string[] {
   return evaluations.map((evaluation) => {
-    const status =
-      evaluation.passed === true
-        ? "PASSED"
-        : evaluation.passed === false
-          ? "FAILED"
-          : "N/A";
+    let status = "N/A";
+    if (evaluation.passed === true) {
+      status = "PASSED";
+    } else if (evaluation.passed === false) {
+      status = "FAILED";
+    }
     return `- **${evaluation.name || evaluation.evaluator_id}**: ${status}${evaluation.score != null ? ` (score: ${evaluation.score})` : ""}${evaluation.label ? ` [${evaluation.label}]` : ""}`;
   });
 }

package/src/utils/markdown-table.ts

@@ -0,0 +1,58 @@
+/**
+ * One markdown table renderer for caller-chosen columns. Cells are captured content, so they are
+ * escaped: one pipe in a cell would split the row for every reader.
+ */
+
+import { escapeMarkdown } from "./escape-markdown.ts";
+
+/** Longest a single cell is rendered before it is cut. */
+const MAX_CELL_LENGTH = 200;
+
+/** One cell: escaped, flattened to a line, and bounded. */
+export function markdownCell(value: unknown): string {
+  if (value === null || value === undefined) return "";
+  const text = cellText(value);
+  const escaped = escapeMarkdown(text);
+  return escaped.length > MAX_CELL_LENGTH ? `${escaped.slice(0, MAX_CELL_LENGTH - 1)}…` : escaped;
+}
+
+/**
+ * A markdown table, or a line saying there is nothing to show. `rows` are read by header, so a row
+ * missing a key renders an empty cell rather than shifting every cell after it one column left.
+ */
+export function markdownTable({
+  headers,
+  rows,
+  emptyMessage = "No rows.",
+}: {
+  headers: readonly string[];
+  rows: readonly Record<string, unknown>[];
+  emptyMessage?: string;
+}): string {
+  if (headers.length === 0 || rows.length === 0) return emptyMessage;
+  const lines = [
+    `| ${headers.map(markdownCell).join(" | ")} |`,
+    `| ${headers.map(() => "---").join(" | ")} |`,
+  ];
+  for (const row of rows) {
+    lines.push(`| ${headers.map((header) => markdownCell(row[header])).join(" | ")} |`);
+  }
+  return lines.join("\n");
+}
+
+function cellText(value: {}): string {
+  switch (typeof value) {
+    case "string":
+      return value;
+    case "number":
+    case "boolean":
+    case "bigint":
+      return String(value);
+    case "symbol":
+      return value.toString();
+    case "function":
+      return value.name;
+    default:
+      return JSON.stringify(value);
+  }
+}

package/src/utils/trace-id-shape.ts

@@ -0,0 +1,20 @@
+/**
+ * Whether a free-text query looks like a trace id. Advisory only: it adds a sentence to an
+ * empty result (ADR-164). Restates the platform's trace-id constants; no server code is shared.
+ */
+
+/** Hex-only, matching the server's prefix resolver. */
+const HEX_ONLY = /^[0-9a-f]+$/i;
+
+/** Shortest hex string worth calling an id; no upper bound (CLI truncates to 20, OTel is 32). */
+const MIN_TRACE_ID_LENGTH = 8;
+
+/** The `trace_`-prefixed form the collector accepts (`trace_` + nanoid). */
+const PREFIXED_TRACE_ID = /^trace_[A-Za-z0-9_-]{8,}$/;
+
+export function looksLikeTraceId(query: string): boolean {
+  const candidate = query.trim();
+  if (candidate.includes(" ")) return false;
+  if (PREFIXED_TRACE_ID.test(candidate)) return true;
+  return HEX_ONLY.test(candidate) && candidate.length >= MIN_TRACE_ID_LENGTH;
+}

package/tsconfig.app.json

@@ -0,0 +1,24 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "composite": false,
+    "noEmit": true,
+    "tsBuildInfoFile": "dist/tsconfig.app.tsbuildinfo"
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["node_modules", "./dist/**/*", "./example/**/*"],
+  "references": [
+    {
+      "path": "../../modules/evaluator/contract/tsconfig.build.json"
+    },
+    {
+      "path": "../../packages/redaction/tsconfig.build.json"
+    },
+    {
+      "path": "../../packages/handled-error/tsconfig.build.json"
+    },
+    {
+      "path": "../../packages/egress/tsconfig.build.json"
+    }
+  ]
+}

package/tsconfig.json

@@ -1,18 +1,18 @@
 {
+  "extends": "../../tsconfig.shared.json",
   "compilerOptions": {
-    "target": "ES2022",
+    // This package emits declarations only (tsup writes the JavaScript), so
+    // `noEmit` from the shared base is turned back off for them.
+    "noEmit": false,
+    "emitDeclarationOnly": true,
     "module": "ESNext",
     "declaration": true,
     "declarationMap": true,
     "outDir": "./dist",
-    "strict": true,
     "esModuleInterop": true,
     "resolveJsonModule": true,
     "allowJs": true,
     "checkJs": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "moduleResolution": "bundler",
     "rootDir": "../..",
     // The evaluator catalog we import (services/langevals/ts-integration/evaluators.generated.ts)
     // is Zod-first and imports `zod`, but lives outside this package's
@@ -20,15 +20,22 @@
     // package's own copy (a declared dependency) so the type-checker resolves it.
     // Paths are resolved relative to this tsconfig (no baseUrl — tsgo removed it).
     "paths": { "zod": ["./node_modules/zod"] },
+    // tsup's dts worker sets `baseUrl` itself, and TypeScript 6 makes that a
+    // hard error rather than a warning — this package cannot build without the
+    // transition flag until a d.ts bundler exists that speaks the TypeScript 7
+    // API. See ADR-099.
+    "ignoreDeprecations": "6.0",
     "isolatedModules": true,
     "jsx": "preserve",
-    "incremental": true,
     "noUncheckedIndexedAccess": true,
-    "tsBuildInfoFile": "./tsconfig.tsbuildinfo"
+    "tsBuildInfoFile": "dist/tsconfig.typecheck.tsbuildinfo",
+    "composite": true
   },
-  "include": [
-    ".eslintrc.cjs",
-    "**/*.ts",
-  ],
-  "exclude": ["node_modules", "./dist/**/*", "./example/**/*"]
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.app.json"
+    }
+  ]
 }