@langwatch/mcp-server 2.1.0 → 3.0.0

package/dist/chunk-3YLN3ATJ.js

@@ -0,0 +1,241 @@
+// src/schemas/triggers.ts
+import { z } from "zod";
+var triggerActionSchema = z.enum([
+  "SEND_EMAIL",
+  "SEND_SLACK_MESSAGE",
+  "SEND_WEBHOOK",
+  "ADD_TO_DATASET",
+  "ADD_TO_ANNOTATION_QUEUE"
+]);
+var alertTypeSchema = z.enum(["CRITICAL", "WARNING", "INFO"]);
+var emailActionParamsSchema = z.object({
+  members: z.array(z.string()).min(1).describe("Who receives the email. Any address, not only teammates.")
+}).passthrough();
+var slackActionParamsSchema = z.object({
+  slackIntegrationId: z.string().optional().describe(
+    "The Slack connection to post through (an organization connection or one of this project's; they are listed in LangWatch under Settings, Integrations, Slack). A bot connection also needs `slackChannelId`; a webhook connection needs nothing else. Preferred over `slackWebhook` and `slackBotToken`."
+  ),
+  slackDelivery: z.enum(["webhook", "bot"]).optional().describe(
+    "How the message reaches Slack. `webhook` posts to an incoming webhook URL, `bot` posts as the LangWatch Slack app. With `slackIntegrationId` it follows the connection's kind. Absent without a connection means `webhook`."
+  ),
+  slackWebhook: z.string().optional().describe(
+    "Legacy, accepted for one release: an incoming webhook URL (https://hooks.slack.com/...). It is stored as a Slack connection and the automation keeps only the connection id. Send `slackIntegrationId` instead."
+  ),
+  slackChannelId: z.string().optional().describe("The channel the bot posts in, for a bot connection or `bot` delivery."),
+  slackBotToken: z.string().optional().describe(
+    "Legacy, accepted for one release: a bot token, stored as a Slack connection. It never reads back. Send `slackIntegrationId` instead."
+  ),
+  slackBotTokenSet: z.boolean().optional().describe(
+    "Legacy. Read: whether an automation not yet moved to a connection stores its own bot token. Write: true keeps it."
+  )
+}).passthrough();
+var webhookActionParamsSchema = z.object({
+  url: z.string().describe("Where the request goes. https only, and not a private host."),
+  method: z.enum(["POST", "PUT", "PATCH"]).optional(),
+  headers: z.record(z.string(), z.string()).optional().describe(
+    "Static headers sent with every delivery. The values are credentials: they read back as [redacted], and sending [redacted] back keeps the stored ones. Changing `url` means sending the values again in the same call."
+  ),
+  bodyTemplate: z.string().nullable().optional().describe(
+    "A Liquid template for the JSON body. Absent sends the standard LangWatch envelope."
+  ),
+  signingSecret: z.string().nullable().optional().describe("Signs every delivery so the receiver can verify it.")
+}).passthrough();
+var datasetActionParamsSchema = z.object({
+  datasetId: z.string().describe("The dataset matched traces are appended to."),
+  datasetMapping: z.object({
+    mapping: z.record(z.string(), z.unknown()),
+    expansions: z.array(z.string()).optional()
+  }).describe("How a trace becomes a row in that dataset.")
+}).passthrough();
+var annotationQueueActionParamsSchema = z.object({
+  annotators: z.array(z.object({ id: z.string(), name: z.string() })).min(1).describe("Who the queued items go to.")
+}).passthrough();
+var actionParamsSchema = z.union([
+  emailActionParamsSchema,
+  slackActionParamsSchema,
+  webhookActionParamsSchema,
+  datasetActionParamsSchema,
+  annotationQueueActionParamsSchema
+]);
+var slackActionParamsWriteSchema = slackActionParamsSchema.superRefine((params, ctx) => {
+  const delivery = params.slackDelivery ?? "webhook";
+  if (delivery === "bot" && !params.slackChannelId) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["slackChannelId"],
+      message: params.slackIntegrationId ? "a bot connection needs the channel to post in" : "bot delivery needs the channel to post in"
+    });
+  }
+  if (params.slackIntegrationId) return;
+  if (delivery === "webhook" && !params.slackWebhook) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["slackIntegrationId"],
+      message: "name the Slack connection to post through"
+    });
+  }
+  if (delivery === "bot" && !params.slackBotToken && params.slackBotTokenSet !== true) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["slackIntegrationId"],
+      message: "bot delivery needs the Slack connection to post through"
+    });
+  }
+});
+var ACTION_PARAMS_SCHEMA_BY_ACTION = {
+  SEND_EMAIL: emailActionParamsSchema,
+  SEND_SLACK_MESSAGE: slackActionParamsWriteSchema,
+  SEND_WEBHOOK: webhookActionParamsSchema,
+  ADD_TO_DATASET: datasetActionParamsSchema,
+  ADD_TO_ANNOTATION_QUEUE: annotationQueueActionParamsSchema
+};
+function validateActionParamsForAction({
+  action,
+  actionParams
+}) {
+  const schema = ACTION_PARAMS_SCHEMA_BY_ACTION[action] ?? actionParamsSchema;
+  const parsed = schema.safeParse(actionParams);
+  if (parsed.success) return { ok: true };
+  const issues = parsed.error.issues.map((issue) => `${issue.path.join(".") || "(actionParams)"}: ${issue.message}`).join("; ");
+  return {
+    ok: false,
+    message: `actionParams does not fit ${action} \u2014 ${issues}`
+  };
+}
+var TRIGGER_FILTERS_DESCRIPTION = [
+  "Trace conditions as a JSON object string.",
+  'Unkeyed fields take a list of values: {"traces.error":["true"]}.',
+  'Keyed fields nest a key above the list. evaluations.* is keyed by the MONITOR id (the `id` from `platform_list_monitors` / GET /api/v1/monitors, not its evaluatorId): {"evaluations.passed":{"<monitorId>":["false"]}}.',
+  'metadata.value is keyed by the metadata key: {"metadata.value":{"<key>":["true"]}}.',
+  "A keyed field sent as a bare list, or keyed by anything but a monitor id, is refused."
+].join(" ");
+var TRIGGER_FILTER_QUERY_DESCRIPTION = [
+  "Trace query in the syntax the traces view uses; the alternative to `filters`, and it supersedes them.",
+  'Examples: status:error \xB7 evaluator:"<evaluator name>" AND evaluatorVerdict:fail \xB7 trace.attribute.<key>:<value>.'
+].join(" ");
+var SLACK_DELIVERY_NOTE = 'For SEND_SLACK_MESSAGE, send {"slackIntegrationId":"<connection id>"} for a webhook connection, or {"slackIntegrationId":"<connection id>","slackChannelId":"C..."} for a bot connection. Slack connections are listed and added in LangWatch under Settings, Integrations, Slack (organization-wide or for one project); they are also listed by GET /api/v1/slack-connections and `langwatch slack-connection list`, or ask the user for the id. slackIntegrationId is preferred: a legacy {"slackWebhook":"https://hooks.slack.com/..."} or {"slackDelivery":"bot","slackBotToken":"xoxb-...","slackChannelId":"C..."} is still accepted for one release and is stored as a connection. A Slack automation with no connection will never post.';
+var graphAlertSchema = z.object({
+  seriesName: z.string().describe("The series on the graph to watch."),
+  operator: z.enum(["gt", "lt", "gte", "lte", "eq"]),
+  threshold: z.number(),
+  timePeriod: z.union([
+    z.literal(1),
+    z.literal(5),
+    z.literal(15),
+    z.literal(30),
+    z.literal(60),
+    z.literal(1440)
+  ]).describe("The window, in minutes, the series is read over.")
+}).describe("The rule an alert fires by. Send it with `customGraphId` and `alertType`.");
+var reportSchema = z.object({
+  source: z.discriminatedUnion("kind", [
+    z.object({
+      kind: z.literal("dashboard"),
+      dashboardId: z.string()
+    }),
+    z.object({
+      kind: z.literal("customGraph"),
+      customGraphId: z.string()
+    }),
+    z.object({
+      kind: z.literal("traceQuery"),
+      filters: z.record(z.string(), z.unknown()).optional(),
+      metric: z.string().optional(),
+      topN: z.number().int().min(1).max(100).optional()
+    })
+  ]).describe("What the report renders: a dashboard, one graph, or a table of traces."),
+  schedule: z.object({
+    cron: z.string().describe(
+      'A 5-field cron expression (minute hour day-of-month month day-of-week), for example "0 9 * * 1". It can send at most every 15 minutes.'
+    ),
+    timezone: z.string().describe('An IANA timezone, for example "Europe/Amsterdam" or "UTC".')
+  }).describe("When it sends."),
+  compareToPrevious: z.boolean().optional().describe("Include a this-period-versus-last comparison.")
+}).describe(
+  "What a scheduled report renders and when. Send it with a channel that can carry a message: email or Slack."
+);
+var templatesSchema = z.object({
+  slackTemplateType: z.enum(["string", "block_kit"]).nullable().optional(),
+  slackTemplate: z.string().nullable().optional(),
+  emailSubjectTemplate: z.string().nullable().optional(),
+  emailBodyTemplate: z.string().nullable().optional()
+}).describe(
+  "The Liquid templates the message is rendered from. Absent fields render the LangWatch default."
+);
+var notificationCadenceSchema = z.enum(["immediate", "5min_digest", "15min_digest", "hourly_digest"]).describe(
+  "How often a notification automation may send. A new one starts on a five-minute digest."
+);
+var triggerSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  action: z.string(),
+  /** Where it delivers. The rule it fires by is stated separately, below,
+   *  the same way a write states it. */
+  actionParams: z.record(z.string(), z.unknown()).default({}),
+  graphAlert: graphAlertSchema.nullable().optional(),
+  // A read stays tolerant of a deployment that words this differently; a
+  // write is held to `reportSchema`.
+  report: z.record(z.string(), z.unknown()).nullable().optional(),
+  filters: z.record(z.string(), z.unknown()).default({}),
+  filterQuery: z.string().nullable().optional(),
+  kind: z.string().optional(),
+  customGraphId: z.string().nullable().optional(),
+  notificationCadence: z.string().nullable().optional(),
+  traceDebounceMs: z.number().nullable().optional(),
+  templates: z.record(z.string(), z.unknown()).optional(),
+  active: z.boolean(),
+  message: z.string().nullable(),
+  alertType: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  platformUrl: z.string().optional()
+}).passthrough();
+var triggerFireSchema = z.object({
+  id: z.string(),
+  triggerId: z.string(),
+  customGraphId: z.string().nullable(),
+  firedAt: z.string(),
+  resolvedAt: z.string().nullable()
+}).passthrough();
+var triggerFirePageSchema = z.union([
+  z.array(triggerFireSchema).transform((fires) => ({ fires, nextCursor: null })),
+  z.object({
+    fires: z.array(triggerFireSchema).optional(),
+    data: z.array(triggerFireSchema).optional(),
+    nextCursor: z.string().nullable().optional()
+  }).transform(({ fires, data, nextCursor }) => ({
+    fires: fires ?? data ?? [],
+    nextCursor: nextCursor ?? null
+  }))
+]);
+var testFireResultSchema = z.object({
+  channel: z.string(),
+  recipientCount: z.number(),
+  usedDefault: z.boolean(),
+  missingVariables: z.array(z.string()).default([]),
+  errors: z.array(z.string()).default([]),
+  httpStatus: z.number().optional()
+}).passthrough();
+var deletedTriggerSchema = z.object({
+  id: z.string(),
+  deleted: z.boolean()
+});
+
+export {
+  triggerActionSchema,
+  alertTypeSchema,
+  actionParamsSchema,
+  validateActionParamsForAction,
+  TRIGGER_FILTERS_DESCRIPTION,
+  TRIGGER_FILTER_QUERY_DESCRIPTION,
+  SLACK_DELIVERY_NOTE,
+  graphAlertSchema,
+  reportSchema,
+  templatesSchema,
+  notificationCadenceSchema,
+  triggerSchema,
+  triggerFirePageSchema,
+  testFireResultSchema,
+  deletedTriggerSchema
+};
+//# sourceMappingURL=chunk-3YLN3ATJ.js.map

package/dist/{chunk-EYXMLE5X.js → chunk-4RX3G62A.js}

@@ -1,6 +1,6 @@
 import {
   makeRequest
-} from "./chunk-GELJ2MQR.js";
+} from "./chunk-7CZQDZ2K.js";
 
 // src/langwatch-api-agents.ts
 import { z } from "zod";
@@ -11,7 +11,7 @@ import { request as httpRequest } from "http";
 import { request as httpsRequest } from "https";
 import { isIP } from "net";
 
-// ../../packages/ssrf/src/index.ts
+// ../../packages/egress/src/ssrf/address.ts
 function ipv4ToBytes(input) {
   const parts = input.split(".");
   if (parts.length !== 4) return null;
@@ -24,6 +24,25 @@ function ipv4ToBytes(input) {
   }
   return bytes;
 }
+function parseIpv6Groups(part) {
+  if (part === "") return [];
+  const out = [];
+  for (const group of part.split(":")) {
+    if (!/^[0-9a-fA-F]{1,4}$/.test(group)) return null;
+    out.push(parseInt(group, 16));
+  }
+  return out;
+}
+function expandIpv6Groups(halves) {
+  const head = parseIpv6Groups(halves[0]);
+  if (head === null) return null;
+  if (halves.length !== 2) return head;
+  const tail = parseIpv6Groups(halves[1]);
+  if (tail === null) return null;
+  const missing = 8 - head.length - tail.length;
+  if (missing < 0) return null;
+  return [...head, ...Array.from({ length: missing }, () => 0), ...tail];
+}
 function ipv6ToBytes(input) {
   let s = input;
   const zone = s.indexOf("%");
@@ -39,27 +58,8 @@ function ipv6ToBytes(input) {
   }
   const halves = s.split("::");
   if (halves.length > 2) return null;
-  const parseGroups = (part) => {
-    if (part === "") return [];
-    const out = [];
-    for (const g of part.split(":")) {
-      if (!/^[0-9a-fA-F]{1,4}$/.test(g)) return null;
-      out.push(parseInt(g, 16));
-    }
-    return out;
-  };
-  const head = parseGroups(halves[0]);
-  if (head === null) return null;
-  let groups;
-  if (halves.length === 2) {
-    const tail = parseGroups(halves[1]);
-    if (tail === null) return null;
-    const missing = 8 - head.length - tail.length;
-    if (missing < 0) return null;
-    groups = [...head, ...new Array(missing).fill(0), ...tail];
-  } else {
-    groups = head;
-  }
+  const groups = expandIpv6Groups(halves);
+  if (groups === null) return null;
   if (groups.length !== 8) return null;
   const bytes = new Uint8Array(16);
   for (let i = 0; i < 8; i++) {
@@ -71,24 +71,31 @@ function ipv6ToBytes(input) {
 function ipToBytes(ip) {
   return ip.includes(":") ? ipv6ToBytes(ip) : ipv4ToBytes(ip);
 }
+function zeroBetween({
+  bytes,
+  from,
+  to
+}) {
+  for (let i = from; i < to; i++) {
+    if (bytes[i] !== 0) return false;
+  }
+  return true;
+}
 function unmap(bytes) {
   if (bytes.length !== 16) return bytes;
-  for (let i = 0; i < 10; i++) {
-    if (bytes[i] !== 0) return bytes;
-  }
-  if (bytes[10] === 255 && bytes[11] === 255) return bytes.slice(12, 16);
-  return bytes;
+  if (!zeroBetween({ bytes, from: 0, to: 8 })) return bytes;
+  const mapped = zeroBetween({ bytes, from: 8, to: 10 }) && bytes[10] === 255 && bytes[11] === 255;
+  const compatible = zeroBetween({ bytes, from: 8, to: 12 });
+  const translated = bytes[8] === 255 && bytes[9] === 255 && zeroBetween({ bytes, from: 10, to: 12 });
+  return mapped || compatible || translated ? bytes.slice(12, 16) : bytes;
 }
 function parsePrefix({ cidr, rfc }) {
   const slash = cidr.lastIndexOf("/");
   const bytes = ipToBytes(cidr.slice(0, slash));
-  if (!bytes) throw new Error(`@langwatch/ssrf: bad prefix ${cidr}`);
+  if (!bytes) throw new Error(`ssrf: bad prefix ${cidr}`);
   return { bytes, bits: Number(cidr.slice(slash + 1)), rfc };
 }
-function prefixContains({
-  prefix,
-  addr
-}) {
+function prefixContains({ prefix, addr }) {
   if (prefix.bytes.length !== addr.length) return false;
   let bits = prefix.bits;
   let i = 0;
@@ -110,6 +117,10 @@ var METADATA_ADDRESSES = [
   // AWS ECS/Fargate task metadata
   "168.63.129.16",
   // Azure WireServer / host DNS
+  "100.100.100.200",
+  // Alibaba Cloud ECS metadata
+  "192.0.0.192",
+  // Oracle Cloud metadata
   "fd00:ec2::254"
   // AWS EC2 IMDS over IPv6
 ].map((ip) => {
@@ -175,12 +186,14 @@ function bytesEqual({ a, b }) {
   }
   return true;
 }
+function isMetadataAddress(addr) {
+  return METADATA_ADDRESSES.some((m) => bytesEqual({ a: m, b: addr }));
+}
 function classify(ip) {
   const raw = ipToBytes(ip);
   if (!raw) return "special";
   const addr = unmap(raw);
-  if (METADATA_ADDRESSES.some((m) => bytesEqual({ a: m, b: addr })))
-    return "metadata";
+  if (isMetadataAddress(addr)) return "metadata";
   for (const prefix of SPECIAL_PREFIXES) {
     if (prefixContains({ prefix, addr })) return "special";
   }
@@ -203,7 +216,9 @@ var SENSITIVE_REDIRECT_HEADERS = /* @__PURE__ */ new Set([
   "x-access-token"
 ]);
 function unsafeDestinationError() {
-  return new Error("HTTP agent destinations must resolve only to globally routable public addresses");
+  return new Error(
+    "HTTP agent destinations must resolve only to globally routable public addresses"
+  );
 }
 function hostnameWithoutBrackets(hostname) {
   return hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
@@ -380,10 +395,7 @@ async function listAgents(params) {
   return makeRequest("GET", `/api/v1/agents${qs}`);
 }
 async function getAgent(id) {
-  return makeRequest(
-    "GET",
-    `/api/v1/agents/${encodeURIComponent(id)}`
-  );
+  return makeRequest("GET", `/api/v1/agents/${encodeURIComponent(id)}`);
 }
 async function createAgent(data) {
   return makeRequest("POST", "/api/v1/agents", data);
@@ -443,7 +455,7 @@ function buildRelayBody({
     }
     inputParams = parsed.data;
   }
-  if (inputParams || parameters) body.params = { ...inputParams ?? {}, ...parameters ?? {} };
+  if (inputParams || parameters) body.params = { ...inputParams, ...parameters };
   return body;
 }
 async function runAgent({
@@ -484,15 +496,12 @@ async function runAgent({
       `Agent "${agent.name}" (type: ${agent.type}) cannot be executed directly. Only connected agents, HTTP agents and workflow-linked agents can be run.`
     );
   }
-  const { runWorkflow } = await import("./langwatch-api-workflows-6UJL5U4Z.js");
+  const { runWorkflow } = await import("./langwatch-api-workflows-OMROZH2O.js");
   const result = await runWorkflow(workflowId, input);
   return { agentType: agent.type, result };
 }
 async function deleteAgent(id) {
-  return makeRequest(
-    "DELETE",
-    `/api/v1/agents/${encodeURIComponent(id)}`
-  );
+  return makeRequest("DELETE", `/api/v1/agents/${encodeURIComponent(id)}`);
 }
 
 export {
@@ -504,4 +513,4 @@ export {
   runAgent,
   deleteAgent
 };
-//# sourceMappingURL=chunk-EYXMLE5X.js.map
+//# sourceMappingURL=chunk-4RX3G62A.js.map

package/dist/{chunk-UF6XIGYR.js → chunk-6YZUOD34.js}

@@ -4,10 +4,7 @@ function describeMapping(mapping) {
 }
 function formatSuiteFields(fields) {
   if (!fields || fields.length === 0) return [];
-  return [
-    "\n## Fields",
-    ...fields.map((field) => `- ${field.identifier} (${field.type})`)
-  ];
+  return ["\n## Fields", ...fields.map((field) => `- ${field.identifier} (${field.type})`)];
 }
 function formatEvaluatorAttachments(evaluators) {
   if (!evaluators || evaluators.length === 0) return [];
@@ -55,4 +52,4 @@ export {
   pendingEvaluationNote,
   formatEvaluations
 };
-//# sourceMappingURL=chunk-UF6XIGYR.js.map
+//# sourceMappingURL=chunk-6YZUOD34.js.map

package/dist/{chunk-WVI5CJ6S.js → chunk-7AQLPVFL.js}

@@ -1,6 +1,6 @@
 import {
   escapeMarkdown
-} from "./chunk-NUFPTHKU.js";
+} from "./chunk-FOKVY3BK.js";
 
 // src/tools/format-dataset-mutation.ts
 function formatDatasetMutationDetails(result) {
@@ -18,4 +18,4 @@ function formatDatasetMutationDetails(result) {
 export {
   formatDatasetMutationDetails
 };
-//# sourceMappingURL=chunk-WVI5CJ6S.js.map
+//# sourceMappingURL=chunk-7AQLPVFL.js.map