@langwatch/mcp-server 2.0.0 → 2.2.0

package/dist/chunk-UWLE5T2F.js

@@ -0,0 +1,312 @@
+import {
+  getConfig,
+  requireApiKey
+} from "./chunk-H6WGMG2T.js";
+
+// package.json
+var package_default = {
+  name: "@langwatch/mcp-server",
+  version: "2.2.0",
+  description: "An MCP server for Langwatch.",
+  license: "MIT",
+  author: "",
+  repository: {
+    type: "git",
+    url: "https://github.com/langwatch/langwatch.git",
+    directory: "mcp-server"
+  },
+  bin: {
+    "langwatch-mcp-server": "./dist/index.js"
+  },
+  type: "module",
+  main: "./dist/index.js",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      import: "./dist/index.js"
+    },
+    "./create-mcp-server": {
+      types: "./src/create-mcp-server.d.ts",
+      import: "./dist/create-mcp-server.js",
+      require: "./dist/create-mcp-server.cjs",
+      default: "./dist/create-mcp-server.js"
+    },
+    "./config": {
+      types: "./src/config.d.ts",
+      import: "./dist/config.js",
+      require: "./dist/config.cjs",
+      default: "./dist/config.js"
+    }
+  },
+  scripts: {
+    start: "node --experimental-transform-types src/index.ts",
+    build: "tsup && node build.js",
+    typecheck: "GOMAXPROCS=2 GOMEMLIMIT=2GiB pnpm -w exec tsc -b mcp/typescript",
+    prepublish: "pnpm run build",
+    test: "vitest run",
+    "test:integration": "vitest run --config vitest.integration.config.js",
+    "test:scenario": "vitest run --config vitest.scenario.config.js"
+  },
+  dependencies: {
+    "@langwatch/evaluator-contract": "workspace:*",
+    "@modelcontextprotocol/sdk": "catalog:",
+    zod: "catalog:"
+  },
+  devDependencies: {
+    "@ai-sdk/anthropic": "catalog:",
+    "@anthropic-ai/claude-code": "2.1.228",
+    "@langwatch/egress": "workspace:*",
+    "@langwatch/handled-error": "workspace:*",
+    "@langwatch/redaction": "workspace:*",
+    "@langwatch/scenario": "catalog:",
+    "@types/debug": "catalog:",
+    "@types/express": "^5.0.6",
+    "@types/node": "catalog:",
+    "@types/yargs": "^17.0.33",
+    ai: "catalog:",
+    chalk: "catalog:",
+    dotenv: "catalog:",
+    esbuild: "catalog:",
+    express: "^5.2.1",
+    "node-pty": "catalog:",
+    tsup: "catalog:",
+    typescript: "catalog:sdk-toolchain",
+    vitest: "catalog:",
+    yargs: "^18.0.0",
+    "zod-validation-error": "catalog:"
+  },
+  engines: {
+    node: "^22.23.4 || ^24.22.1 || >=26.12.1"
+  }
+};
+
+// src/langwatch-api.ts
+var MCP_IDENTITY_HEADERS = {
+  "User-Agent": `langwatch-mcp/${package_default.version}`,
+  "X-LangWatch-SDK-Name": "langwatch-mcp",
+  "X-LangWatch-SDK-Language": "typescript",
+  "X-LangWatch-SDK-Version": package_default.version
+};
+var LangWatchApiError = class extends Error {
+  constructor(message, status, responseBody, options = {}) {
+    super(message);
+    this.status = status;
+    this.responseBody = responseBody;
+    this.name = "LangWatchApiError";
+    this.code = options.code;
+    this.tips = options.tips;
+    this.docsUrl = options.docsUrl;
+    this.fault = options.fault;
+    this.reasons = options.reasons;
+  }
+  status;
+  responseBody;
+  code;
+  tips;
+  docsUrl;
+  fault;
+  /**
+   * The per-field failures behind this error, verbatim from the envelope. A validation failure
+   * carries the offending field and the values it would have accepted here — the difference
+   * between an agent correcting its own request and an agent guessing again.
+   */
+  reasons;
+};
+var VALID_FAULTS = [
+  "customer",
+  "platform",
+  "provider",
+  "presumed_platform"
+];
+function parseErrorBody(responseBody) {
+  try {
+    const parsed = JSON.parse(responseBody);
+    if (!isRecord(parsed)) return {};
+    const envelope = parsed;
+    const nestedValue = envelope.error;
+    const nested = isRecord(nestedValue) ? nestedValue : null;
+    const body = nested ?? envelope;
+    const code = readErrorCode(body);
+    const message = typeof body.message === "string" ? body.message : void 0;
+    if (code === void 0 && message === void 0) {
+      return {};
+    }
+    const tips = readStringArray(body.tips);
+    const docsUrl = typeof body.docsUrl === "string" ? body.docsUrl : void 0;
+    const fault = VALID_FAULTS.includes(body.fault) ? body.fault : void 0;
+    const reasons = Array.isArray(body.reasons) && body.reasons.every((r) => !!r && typeof r === "object") ? body.reasons : void 0;
+    return { code, message, tips, docsUrl, fault, reasons };
+  } catch {
+    return {};
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readErrorCode(body) {
+  if (typeof body.code === "string") return body.code;
+  if (typeof body.error === "string") return body.error;
+  return void 0;
+}
+function readStringArray(value) {
+  if (!Array.isArray(value) || !value.every(isString)) return void 0;
+  return value;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function describeReason(reason) {
+  const meta = reason.meta;
+  if (!meta || typeof meta !== "object") return null;
+  const field = typeof meta.field === "string" ? meta.field : null;
+  if (!field) return null;
+  const parts = [`- ${field}`];
+  if (meta.received !== void 0) {
+    parts.push(`received ${JSON.stringify(meta.received)}`);
+  }
+  if (Array.isArray(meta.expected) && meta.expected.length > 0) {
+    parts.push(`expected one of: ${meta.expected.join(", ")}`);
+  }
+  return parts.join(" \u2014 ");
+}
+async function makeRequest(method, path, body) {
+  const config = getConfig();
+  const url = config.endpoint + path;
+  const headers = {
+    ...MCP_IDENTITY_HEADERS,
+    "X-Auth-Token": requireApiKey()
+  };
+  if (config.projectId) {
+    headers["X-Project-Id"] = config.projectId;
+  }
+  if (body !== void 0) {
+    headers["Content-Type"] = "application/json";
+  }
+  const response = await fetch(url, {
+    method,
+    headers,
+    ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+  });
+  if (!response.ok) {
+    const responseBody = await response.text();
+    const parsed = parseErrorBody(responseBody);
+    const lines = [`LangWatch API error ${response.status}: ${parsed.message ?? responseBody}`];
+    const reasonLines = (parsed.reasons ?? []).map(describeReason).filter((line) => line !== null);
+    if (reasonLines.length > 0) {
+      lines.push("Rejected fields:", ...reasonLines);
+    }
+    if (parsed.tips && parsed.tips.length > 0) {
+      lines.push("Tips:", ...parsed.tips.map((tip) => `- ${tip}`));
+    }
+    if (parsed.docsUrl) {
+      lines.push(`Docs: ${parsed.docsUrl}`);
+    }
+    throw new LangWatchApiError(lines.join("\n"), response.status, responseBody, {
+      code: parsed.code,
+      tips: parsed.tips,
+      docsUrl: parsed.docsUrl,
+      fault: parsed.fault,
+      reasons: parsed.reasons
+    });
+  }
+  if (response.status === 204 || response.headers?.get("content-length") === "0") {
+    return null;
+  }
+  return response.json();
+}
+async function searchTraces(params) {
+  const { format = "digest", ...rest } = params;
+  return makeRequest("POST", "/api/v1/traces/search", {
+    ...rest,
+    format
+  });
+}
+async function getTraceById(traceId, format = "digest") {
+  return makeRequest(
+    "GET",
+    `/api/v1/traces/${encodeURIComponent(traceId)}?format=${format}`
+  );
+}
+async function getAnalyticsTimeseries(params) {
+  return makeRequest(
+    "POST",
+    "/api/v1/analytics/timeseries",
+    params
+  );
+}
+async function listPrompts() {
+  return makeRequest("GET", "/api/v1/prompts");
+}
+async function getPrompt(idOrHandle, options) {
+  const params = new URLSearchParams();
+  if (options?.version != null) params.set("version", String(options.version));
+  if (options?.tag) params.set("tag", options.tag);
+  const query = params.toString() ? `?${params}` : "";
+  return makeRequest(
+    "GET",
+    `/api/v1/prompts/${encodeURIComponent(idOrHandle)}${query}`
+  );
+}
+async function getPromptVersions(idOrHandle) {
+  return makeRequest(
+    "GET",
+    `/api/v1/prompts/${encodeURIComponent(idOrHandle)}/versions`
+  );
+}
+async function createPrompt(data) {
+  return makeRequest("POST", "/api/v1/prompts", data);
+}
+async function updatePrompt(idOrHandle, data) {
+  return makeRequest(
+    "PUT",
+    `/api/v1/prompts/${encodeURIComponent(idOrHandle)}`,
+    data
+  );
+}
+async function assignPromptTag({
+  idOrHandle,
+  tag,
+  versionId
+}) {
+  return makeRequest(
+    "PUT",
+    `/api/v1/prompts/${encodeURIComponent(idOrHandle)}/tags/${encodeURIComponent(tag)}`,
+    { versionId }
+  );
+}
+async function listPromptTags() {
+  return makeRequest("GET", "/api/v1/prompts/tags");
+}
+async function createPromptTag(name) {
+  return makeRequest("POST", "/api/v1/prompts/tags", { name });
+}
+async function renamePromptTag({
+  tag,
+  name
+}) {
+  return makeRequest("PUT", `/api/v1/prompts/tags/${encodeURIComponent(tag)}`, { name });
+}
+async function deletePromptTag(tag) {
+  return makeRequest("DELETE", `/api/v1/prompts/tags/${encodeURIComponent(tag)}`);
+}
+
+export {
+  package_default,
+  LangWatchApiError,
+  makeRequest,
+  searchTraces,
+  getTraceById,
+  getAnalyticsTimeseries,
+  listPrompts,
+  getPrompt,
+  getPromptVersions,
+  createPrompt,
+  updatePrompt,
+  assignPromptTag,
+  listPromptTags,
+  createPromptTag,
+  renamePromptTag,
+  deletePromptTag
+};
+//# sourceMappingURL=chunk-UWLE5T2F.js.map

package/dist/chunk-VMWJD732.js

@@ -0,0 +1,57 @@
+import {
+  makeRequest
+} from "./chunk-UWLE5T2F.js";
+
+// src/langwatch-api-test-suites.ts
+async function listTestSuites() {
+  return makeRequest("GET", "/api/v1/test-suites");
+}
+async function createTestSuite(data) {
+  return makeRequest("POST", "/api/v1/test-suites", data);
+}
+async function getTestSuite(id) {
+  return makeRequest(
+    "GET",
+    `/api/v1/test-suites/${encodeURIComponent(id)}`
+  );
+}
+async function updateTestSuite(params) {
+  const { id, ...data } = params;
+  return makeRequest(
+    "PATCH",
+    `/api/v1/test-suites/${encodeURIComponent(id)}`,
+    data
+  );
+}
+async function renameTestSuite(params) {
+  return makeRequest("PATCH", `/api/v1/test-suites/${encodeURIComponent(params.id)}`, {
+    name: params.name
+  });
+}
+async function archiveTestSuite(id) {
+  return makeRequest(
+    "DELETE",
+    `/api/v1/test-suites/${encodeURIComponent(id)}`
+  );
+}
+async function runTestSuite({
+  id,
+  ...data
+}) {
+  return makeRequest(
+    "POST",
+    `/api/v1/test-suites/${encodeURIComponent(id)}/run`,
+    data
+  );
+}
+
+export {
+  listTestSuites,
+  createTestSuite,
+  getTestSuite,
+  updateTestSuite,
+  renameTestSuite,
+  archiveTestSuite,
+  runTestSuite
+};
+//# sourceMappingURL=chunk-VMWJD732.js.map

package/dist/chunk-XUIJYNRJ.js

@@ -0,0 +1,15 @@
+// src/tools/format-scenario.ts
+function formatScenarioFields(fields) {
+  if (!fields || Object.keys(fields).length === 0) return [];
+  return [
+    "\n## Fields",
+    ...Object.entries(fields).map(
+      ([identifier, value]) => `- ${identifier}: ${JSON.stringify(value)}`
+    )
+  ];
+}
+
+export {
+  formatScenarioFields
+};
+//# sourceMappingURL=chunk-XUIJYNRJ.js.map

package/dist/chunk-Y34DHR5K.js

@@ -0,0 +1,67 @@
+import {
+  deletedTriggerSchema,
+  testFireResultSchema,
+  triggerFirePageSchema,
+  triggerSchema
+} from "./chunk-3YLN3ATJ.js";
+import {
+  makeRequest
+} from "./chunk-UWLE5T2F.js";
+
+// src/langwatch-api-triggers.ts
+import { z } from "zod";
+async function listTriggers() {
+  return z.array(triggerSchema).parse(await makeRequest("GET", "/api/v1/triggers"));
+}
+async function getTrigger(id) {
+  return triggerSchema.parse(
+    await makeRequest("GET", `/api/v1/triggers/${encodeURIComponent(id)}`)
+  );
+}
+async function createTrigger(input) {
+  return triggerSchema.parse(
+    await makeRequest("POST", "/api/v1/triggers", {
+      ...input,
+      actionParams: input.actionParams ?? {}
+    })
+  );
+}
+async function updateTrigger({ id, ...data }) {
+  return triggerSchema.parse(
+    await makeRequest("PATCH", `/api/v1/triggers/${encodeURIComponent(id)}`, data)
+  );
+}
+async function testFireTrigger(id) {
+  return testFireResultSchema.parse(
+    await makeRequest("POST", `/api/v1/triggers/${encodeURIComponent(id)}/test-fire`)
+  );
+}
+async function listTriggerFires({
+  id,
+  limit,
+  cursor
+}) {
+  const query = new URLSearchParams();
+  if (limit !== void 0) query.set("limit", String(limit));
+  if (cursor) query.set("cursor", cursor);
+  const search = query.toString() ? `?${query.toString()}` : "";
+  return triggerFirePageSchema.parse(
+    await makeRequest("GET", `/api/v1/triggers/${encodeURIComponent(id)}/fires${search}`)
+  );
+}
+async function deleteTrigger(id) {
+  return deletedTriggerSchema.parse(
+    await makeRequest("DELETE", `/api/v1/triggers/${encodeURIComponent(id)}`)
+  );
+}
+
+export {
+  listTriggers,
+  getTrigger,
+  createTrigger,
+  updateTrigger,
+  testFireTrigger,
+  listTriggerFires,
+  deleteTrigger
+};
+//# sourceMappingURL=chunk-Y34DHR5K.js.map