@langwatch/mcp-server 2.1.0 → 3.0.0

package/dist/chunk-EYPJBL7P.js

@@ -0,0 +1,516 @@
+import {
+  makeRequest
+} from "./chunk-7CZQDZ2K.js";
+
+// src/langwatch-api-agents.ts
+import { z } from "zod";
+
+// src/public-http-request.ts
+import { lookup as dnsLookup } from "dns/promises";
+import { request as httpRequest } from "http";
+import { request as httpsRequest } from "https";
+import { isIP } from "net";
+
+// ../../packages/egress/src/ssrf/address.ts
+function ipv4ToBytes(input) {
+  const parts = input.split(".");
+  if (parts.length !== 4) return null;
+  const bytes = new Uint8Array(4);
+  for (let i = 0; i < 4; i++) {
+    if (!/^\d{1,3}$/.test(parts[i])) return null;
+    const n = Number(parts[i]);
+    if (n > 255) return null;
+    bytes[i] = n;
+  }
+  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("%");
+  if (zone !== -1) s = s.slice(0, zone);
+  if (s.includes(".")) {
+    const lastColon = s.lastIndexOf(":");
+    if (lastColon === -1) return null;
+    const v4 = ipv4ToBytes(s.slice(lastColon + 1));
+    if (!v4) return null;
+    const hi = (v4[0] << 8 | v4[1]).toString(16);
+    const lo = (v4[2] << 8 | v4[3]).toString(16);
+    s = `${s.slice(0, lastColon + 1)}${hi}:${lo}`;
+  }
+  const halves = s.split("::");
+  if (halves.length > 2) return null;
+  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++) {
+    bytes[i * 2] = groups[i] >> 8 & 255;
+    bytes[i * 2 + 1] = groups[i] & 255;
+  }
+  return bytes;
+}
+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;
+  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(`ssrf: bad prefix ${cidr}`);
+  return { bytes, bits: Number(cidr.slice(slash + 1)), rfc };
+}
+function prefixContains({ prefix, addr }) {
+  if (prefix.bytes.length !== addr.length) return false;
+  let bits = prefix.bits;
+  let i = 0;
+  while (bits >= 8) {
+    if (prefix.bytes[i] !== addr[i]) return false;
+    i++;
+    bits -= 8;
+  }
+  if (bits > 0) {
+    const mask = 255 << 8 - bits & 255;
+    if ((prefix.bytes[i] & mask) !== (addr[i] & mask)) return false;
+  }
+  return true;
+}
+var METADATA_ADDRESSES = [
+  "169.254.169.254",
+  // AWS/GCP/Azure/Oracle IMDS
+  "169.254.170.2",
+  // 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) => {
+  const bytes = unmap(ipToBytes(ip));
+  return bytes;
+});
+var SPECIAL_PREFIXES = [
+  // IPv4
+  parsePrefix({ cidr: "0.0.0.0/8", rfc: "RFC1122 this network / unspecified" }),
+  parsePrefix({ cidr: "10.0.0.0/8", rfc: "RFC1918 private" }),
+  parsePrefix({
+    cidr: "100.64.0.0/10",
+    rfc: "RFC6598 CGNAT / shared address space"
+  }),
+  parsePrefix({ cidr: "127.0.0.0/8", rfc: "RFC1122 loopback" }),
+  parsePrefix({ cidr: "169.254.0.0/16", rfc: "RFC3927 link-local" }),
+  parsePrefix({ cidr: "172.16.0.0/12", rfc: "RFC1918 private" }),
+  parsePrefix({
+    cidr: "192.0.0.0/24",
+    rfc: "RFC6890 IETF protocol assignments"
+  }),
+  parsePrefix({
+    cidr: "192.0.2.0/24",
+    rfc: "RFC5737 TEST-NET-1 documentation"
+  }),
+  parsePrefix({
+    cidr: "192.88.99.0/24",
+    rfc: "RFC7526 6to4 relay anycast, deprecated"
+  }),
+  parsePrefix({ cidr: "192.168.0.0/16", rfc: "RFC1918 private" }),
+  parsePrefix({ cidr: "198.18.0.0/15", rfc: "RFC2544 benchmarking" }),
+  parsePrefix({
+    cidr: "198.51.100.0/24",
+    rfc: "RFC5737 TEST-NET-2 documentation"
+  }),
+  parsePrefix({
+    cidr: "203.0.113.0/24",
+    rfc: "RFC5737 TEST-NET-3 documentation"
+  }),
+  parsePrefix({ cidr: "224.0.0.0/4", rfc: "RFC5771 multicast" }),
+  parsePrefix({
+    cidr: "240.0.0.0/4",
+    rfc: "RFC1112 reserved incl. 255.255.255.255 broadcast"
+  }),
+  // IPv6
+  parsePrefix({ cidr: "::/128", rfc: "RFC4291 unspecified" }),
+  parsePrefix({ cidr: "::1/128", rfc: "RFC4291 loopback" }),
+  parsePrefix({ cidr: "64:ff9b::/96", rfc: "RFC6052 well-known NAT64" }),
+  parsePrefix({ cidr: "64:ff9b:1::/48", rfc: "RFC8215 local-use NAT64" }),
+  parsePrefix({ cidr: "100::/64", rfc: "RFC6666 discard-only" }),
+  parsePrefix({ cidr: "2001::/32", rfc: "RFC4380 Teredo" }),
+  parsePrefix({ cidr: "2001:db8::/32", rfc: "RFC3849 documentation" }),
+  parsePrefix({ cidr: "2002::/16", rfc: "RFC3056 6to4" }),
+  parsePrefix({ cidr: "3fff::/20", rfc: "RFC9637 documentation" }),
+  parsePrefix({ cidr: "fc00::/7", rfc: "RFC4193 unique-local" }),
+  parsePrefix({ cidr: "fe80::/10", rfc: "RFC4291 link-local unicast" }),
+  parsePrefix({ cidr: "ff00::/8", rfc: "RFC4291 multicast" })
+];
+function bytesEqual({ a, b }) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  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 (isMetadataAddress(addr)) return "metadata";
+  for (const prefix of SPECIAL_PREFIXES) {
+    if (prefixContains({ prefix, addr })) return "special";
+  }
+  return "global";
+}
+
+// src/public-http-request.ts
+var MAX_REDIRECTS = 5;
+var MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
+var REQUEST_TIMEOUT_MS = 3e4;
+var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+var SENSITIVE_REDIRECT_HEADERS = /* @__PURE__ */ new Set([
+  "authorization",
+  "cookie",
+  "cookie2",
+  "proxy-authorization",
+  "x-api-key",
+  "api-key",
+  "x-auth-token",
+  "x-access-token"
+]);
+function unsafeDestinationError() {
+  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;
+}
+function assertPublicAddress(address) {
+  if (classify(address) !== "global") {
+    throw unsafeDestinationError();
+  }
+}
+async function withTimeout(promise, timeoutMs) {
+  let timeout;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_resolve, reject) => {
+        timeout = setTimeout(() => reject(new Error("request timed out")), timeoutMs);
+        timeout.unref();
+      })
+    ]);
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+}
+function headersForRedirect(headers, crossOrigin) {
+  if (!headers || !crossOrigin) {
+    return headers;
+  }
+  const safeHeaders = Object.fromEntries(
+    Object.entries(headers).filter(([name]) => !SENSITIVE_REDIRECT_HEADERS.has(name.toLowerCase()))
+  );
+  return Object.keys(safeHeaders).length > 0 ? safeHeaders : void 0;
+}
+async function resolvePublicDestination(input, resolver = dnsLookup) {
+  let url;
+  try {
+    url = new URL(input);
+  } catch {
+    throw new Error("HTTP agent URL is invalid");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:" || url.username !== "" || url.password !== "") {
+    throw unsafeDestinationError();
+  }
+  const hostname = hostnameWithoutBrackets(url.hostname);
+  const literalFamily = isIP(hostname);
+  if (literalFamily !== 0) {
+    assertPublicAddress(hostname);
+    return { address: hostname, family: literalFamily, url };
+  }
+  let addresses;
+  try {
+    addresses = await withTimeout(
+      resolver(hostname, { all: true, verbatim: true }),
+      REQUEST_TIMEOUT_MS
+    );
+  } catch {
+    throw new Error("HTTP agent destination could not be resolved");
+  }
+  if (addresses.length === 0) {
+    throw new Error("HTTP agent destination could not be resolved");
+  }
+  for (const { address } of addresses) {
+    assertPublicAddress(address);
+  }
+  const selected = addresses.find(({ family }) => family === 4) ?? addresses[0];
+  return {
+    address: selected.address,
+    family: selected.family,
+    url
+  };
+}
+function requestBody(destination, options) {
+  return new Promise((resolve, reject) => {
+    const hostname = hostnameWithoutBrackets(destination.url.hostname);
+    const requestOptions = {
+      protocol: destination.url.protocol,
+      hostname,
+      port: destination.url.port || void 0,
+      path: `${destination.url.pathname}${destination.url.search}`,
+      method: options.method ?? "GET",
+      headers: options.headers,
+      family: destination.family,
+      signal: options.signal,
+      lookup: (_hostname, _options, callback) => {
+        callback(null, destination.address, destination.family);
+      }
+    };
+    const transport = destination.url.protocol === "https:" ? httpsRequest : httpRequest;
+    const request = transport(requestOptions, (response) => {
+      const chunks = [];
+      let receivedBytes = 0;
+      response.once("aborted", () => {
+        reject(new Error("HTTP agent response was interrupted"));
+      });
+      response.once("error", reject);
+      const contentLength = Number(response.headers["content-length"]);
+      if (Number.isFinite(contentLength) && contentLength > MAX_RESPONSE_BYTES) {
+        response.destroy(new Error("HTTP agent response is too large"));
+        return;
+      }
+      response.on("data", (chunk) => {
+        receivedBytes += chunk.length;
+        if (receivedBytes > MAX_RESPONSE_BYTES) {
+          response.destroy(new Error("HTTP agent response is too large"));
+          return;
+        }
+        chunks.push(chunk);
+      });
+      response.once("end", () => {
+        resolve({
+          body: Buffer.concat(chunks).toString("utf8"),
+          location: response.headers.location,
+          statusCode: response.statusCode ?? 0
+        });
+      });
+    });
+    request.once("error", reject);
+    request.setTimeout(REQUEST_TIMEOUT_MS, () => {
+      request.destroy(new Error("HTTP agent request timed out"));
+    });
+    if (options.body !== void 0) {
+      request.write(options.body);
+    }
+    request.end();
+  });
+}
+async function requestPublicJson(input, options = {}, redirectCount = 0) {
+  const destination = await resolvePublicDestination(input);
+  const response = await requestBody(destination, options);
+  if (REDIRECT_STATUSES.has(response.statusCode) && response.location) {
+    if (redirectCount >= MAX_REDIRECTS) {
+      throw new Error(`HTTP agent returned too many redirects`);
+    }
+    const redirectUrl = new URL(response.location, destination.url);
+    const redirectHeaders = headersForRedirect(
+      options.headers,
+      redirectUrl.origin !== destination.url.origin
+    );
+    const preserveBody = response.statusCode === 307 || response.statusCode === 308;
+    return requestPublicJson(
+      redirectUrl.toString(),
+      preserveBody ? { ...options, headers: redirectHeaders } : {
+        ...options,
+        body: void 0,
+        headers: redirectHeaders,
+        method: "GET"
+      },
+      redirectCount + 1
+    );
+  }
+  if (response.statusCode < 200 || response.statusCode >= 300) {
+    throw new Error(`HTTP agent returned an unsuccessful status: ${response.statusCode}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(response.body);
+  } catch {
+    throw new Error("HTTP agent returned invalid JSON");
+  }
+  return parsed;
+}
+
+// src/langwatch-api-agents.ts
+var agentCallParamsSchema = z.record(
+  z.string(),
+  z.union([z.string(), z.number(), z.boolean()])
+);
+async function listAgents(params) {
+  const query = new URLSearchParams();
+  if (params?.page) query.set("page", String(params.page));
+  if (params?.limit) query.set("limit", String(params.limit));
+  const qs = query.toString() ? `?${query}` : "";
+  return makeRequest("GET", `/api/v1/agents${qs}`);
+}
+async function getAgent(id) {
+  return makeRequest("GET", `/api/v1/agents/${encodeURIComponent(id)}`);
+}
+async function createAgent(data) {
+  return makeRequest("POST", "/api/v1/agents", data);
+}
+async function updateAgent(params) {
+  const { id, ...data } = params;
+  return makeRequest(
+    "PATCH",
+    `/api/v1/agents/${encodeURIComponent(id)}`,
+    data
+  );
+}
+async function callAgent({
+  id,
+  body
+}) {
+  return makeRequest(
+    "POST",
+    `/api/v1/agents/${encodeURIComponent(id)}/call`,
+    body
+  );
+}
+async function testAgent(id) {
+  return makeRequest(
+    "POST",
+    `/api/v1/agents/${encodeURIComponent(id)}/test`,
+    {}
+  );
+}
+var isMessageList = (value) => Array.isArray(value) && value.every(
+  (item) => typeof item === "object" && item !== null && typeof item.role === "string"
+);
+function buildRelayBody({
+  input,
+  message,
+  parameters,
+  threadId
+}) {
+  let messages;
+  if (message !== void 0) {
+    messages = [{ role: "user", content: message }];
+  } else if (isMessageList(input.messages)) {
+    messages = input.messages;
+  } else {
+    return "a connected agent takes a conversation: give `message`, or `input` with a `messages` list.";
+  }
+  const body = { messages };
+  const thread = threadId ?? (typeof input.threadId === "string" ? input.threadId : void 0);
+  if (thread) body.threadId = thread;
+  if (isMessageList(input.newMessages)) body.newMessages = input.newMessages;
+  if (input.session !== void 0) body.session = input.session;
+  let inputParams;
+  if (input.params !== void 0) {
+    const parsed = agentCallParamsSchema.safeParse(input.params);
+    if (!parsed.success) {
+      return "`params` takes one flat object of string, number or boolean values. Nested objects and arrays are not run parameters.";
+    }
+    inputParams = parsed.data;
+  }
+  if (inputParams || parameters) body.params = { ...inputParams, ...parameters };
+  return body;
+}
+async function runAgent({
+  id,
+  input,
+  message,
+  parameters,
+  threadId
+}) {
+  const agent = await getAgent(id);
+  const config = agent.config ?? {};
+  if (agent.type === "connected") {
+    const body = buildRelayBody({ input: input ?? {}, message, parameters, threadId });
+    if (typeof body === "string") throw new Error(body);
+    if (agent.status === "offline") {
+      throw new Error(
+        `Agent "${agent.name}" is offline. Start the process that calls connectAgent (or connect_agent) and try again.`
+      );
+    }
+    const result2 = await callAgent({ id: agent.id, body });
+    return { agentType: "connected", result: result2 };
+  }
+  if (agent.type === "http") {
+    const url = config.url;
+    if (!url) {
+      throw new Error("HTTP agent has no URL configured");
+    }
+    const result2 = await requestPublicJson(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(input ?? {})
+    });
+    return { agentType: "http", result: result2 };
+  }
+  const workflowId = config.workflowId;
+  if (!workflowId) {
+    throw new Error(
+      `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-HKTBIKKY.js");
+  const result = await runWorkflow(workflowId, input);
+  return { agentType: agent.type, result };
+}
+async function deleteAgent(id) {
+  return makeRequest("DELETE", `/api/v1/agents/${encodeURIComponent(id)}`);
+}
+
+export {
+  listAgents,
+  getAgent,
+  createAgent,
+  updateAgent,
+  testAgent,
+  runAgent,
+  deleteAgent
+};
+//# sourceMappingURL=chunk-EYPJBL7P.js.map

package/dist/{chunk-NUFPTHKU.js → chunk-FOKVY3BK.js}

@@ -6,4 +6,4 @@ function escapeMarkdown(value) {
 export {
   escapeMarkdown
 };
-//# sourceMappingURL=chunk-NUFPTHKU.js.map
+//# sourceMappingURL=chunk-FOKVY3BK.js.map

package/dist/chunk-GA5JUSPT.js

@@ -0,0 +1,64 @@
+import {
+  escapeMarkdown
+} from "./chunk-FOKVY3BK.js";
+import {
+  makeRequest
+} from "./chunk-7CZQDZ2K.js";
+
+// src/langwatch-api-query.ts
+async function runQuery(params) {
+  return makeRequest("POST", "/api/v1/query", {
+    sql: params.sql,
+    ...params.parameters ? { parameters: params.parameters } : {}
+  });
+}
+async function getQueryReference() {
+  return makeRequest("GET", "/api/v1/query/reference");
+}
+
+// src/utils/markdown-table.ts
+var MAX_CELL_LENGTH = 200;
+function markdownCell(value) {
+  if (value === null || value === void 0) return "";
+  const text = cellText(value);
+  const escaped = escapeMarkdown(text);
+  return escaped.length > MAX_CELL_LENGTH ? `${escaped.slice(0, MAX_CELL_LENGTH - 1)}\u2026` : escaped;
+}
+function markdownTable({
+  headers,
+  rows,
+  emptyMessage = "No rows."
+}) {
+  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) {
+  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);
+  }
+}
+
+export {
+  runQuery,
+  getQueryReference,
+  markdownTable
+};
+//# sourceMappingURL=chunk-GA5JUSPT.js.map