@langwatch/mcp-server 2.0.0 → 2.2.0

package/dist/chunk-YCARO42Z.js

@@ -0,0 +1,516 @@
+import {
+  makeRequest
+} from "./chunk-UWLE5T2F.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-XGJE6SR5.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-YCARO42Z.js.map

package/dist/config-EAKW6F26.js

@@ -0,0 +1,16 @@
+import {
+  getConfig,
+  initConfig,
+  requireApiKey,
+  runWithConfig,
+  tryGetConfig
+} from "./chunk-H6WGMG2T.js";
+import "./chunk-SAS5OB7F.js";
+export {
+  getConfig,
+  initConfig,
+  requireApiKey,
+  runWithConfig,
+  tryGetConfig
+};
+//# sourceMappingURL=config-EAKW6F26.js.map

package/dist/config.cjs

@@ -0,0 +1,109 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config.ts
+var config_exports = {};
+__export(config_exports, {
+  getConfig: () => getConfig,
+  initConfig: () => initConfig,
+  requireApiKey: () => requireApiKey,
+  runWithConfig: () => runWithConfig,
+  tryGetConfig: () => tryGetConfig
+});
+module.exports = __toCommonJS(config_exports);
+var import_node_async_hooks = require("async_hooks");
+var GLOBAL_KEY = "__langwatch_mcp_config";
+var STORAGE_KEY = "__langwatch_mcp_config_storage";
+function getGlobalState() {
+  const g = globalThis;
+  if (!g[GLOBAL_KEY]) {
+    g[GLOBAL_KEY] = void 0;
+  }
+  if (!g[STORAGE_KEY]) {
+    g[STORAGE_KEY] = new import_node_async_hooks.AsyncLocalStorage();
+  }
+  return {
+    get globalConfig() {
+      return g[GLOBAL_KEY];
+    },
+    set globalConfig(val) {
+      g[GLOBAL_KEY] = val;
+    },
+    get configStorage() {
+      return g[STORAGE_KEY];
+    }
+  };
+}
+function normalizeEndpoint(endpoint) {
+  const trimmed = endpoint.trim();
+  let end = trimmed.length;
+  while (end > 0 && trimmed[end - 1] === "/") end--;
+  return trimmed.slice(0, end);
+}
+function initConfig(args) {
+  const state = getGlobalState();
+  state.globalConfig = {
+    apiKey: args.apiKey || process.env.LANGWATCH_API_KEY,
+    endpoint: normalizeEndpoint(args.endpoint ?? "") || normalizeEndpoint(process.env.LANGWATCH_ENDPOINT ?? "") || "https://app.langwatch.ai",
+    projectId: args.projectId ?? process.env.LANGWATCH_PROJECT_ID
+  };
+}
+function tryGetConfig() {
+  const state = getGlobalState();
+  return state.configStorage.getStore() ?? state.globalConfig;
+}
+function getConfig() {
+  const config = tryGetConfig();
+  if (!config) {
+    console.error(
+      "[MCP config] getConfig() failed: globalConfig is null, no scoped config active. Was initConfig() called? Stack:",
+      new Error().stack
+    );
+    throw new Error("Config not initialized");
+  }
+  return config;
+}
+function requireApiKey() {
+  const config = getConfig();
+  if (!config.apiKey) {
+    const state = getGlobalState();
+    const hasScoped = !!state.configStorage.getStore();
+    console.error(
+      `[MCP config] requireApiKey() failed: apiKey is undefined. scopedConfig=${hasScoped}, endpoint=${config.endpoint}. In HTTP mode, the API key should be set per-session via runWithConfig(). Stack:`,
+      new Error().stack
+    );
+    throw new Error(
+      "LANGWATCH_API_KEY is required. Set it via --apiKey flag or LANGWATCH_API_KEY environment variable."
+    );
+  }
+  return config.apiKey;
+}
+function runWithConfig(config, fn) {
+  const state = getGlobalState();
+  return state.configStorage.run(config, fn);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getConfig,
+  initConfig,
+  requireApiKey,
+  runWithConfig,
+  tryGetConfig
+});
+//# sourceMappingURL=config.cjs.map

package/dist/config.js

@@ -2,13 +2,14 @@ import {
   getConfig,
   initConfig,
   requireApiKey,
-  runWithConfig
-} from "./chunk-WT4PO4A3.js";
-import "./chunk-SAS5OB7F.js";
+  runWithConfig,
+  tryGetConfig
+} from "./chunk-H6WGMG2T.js";
 export {
   getConfig,
   initConfig,
   requireApiKey,
-  runWithConfig
+  runWithConfig,
+  tryGetConfig
 };
 //# sourceMappingURL=config.js.map

package/dist/{create-agent-7XHO6UIS.js → create-agent-AYZ3LB3V.js}

@@ -1,8 +1,8 @@
 import {
   createAgent
-} from "./chunk-TOXJQDIZ.js";
-import "./chunk-A2LEVYQ5.js";
-import "./chunk-WT4PO4A3.js";
+} from "./chunk-HGELNIVY.js";
+import "./chunk-UWLE5T2F.js";
+import "./chunk-H6WGMG2T.js";
 import "./chunk-SAS5OB7F.js";
 
 // src/tools/create-agent.ts
@@ -21,4 +21,4 @@ async function handleCreateAgent(params) {
 export {
   handleCreateAgent
 };
-//# sourceMappingURL=create-agent-7XHO6UIS.js.map
+//# sourceMappingURL=create-agent-AYZ3LB3V.js.map

package/dist/create-agent-S5ZBCEFT.js

@@ -0,0 +1,23 @@
+import {
+  createAgent
+} from "./chunk-YCARO42Z.js";
+import "./chunk-UWLE5T2F.js";
+import "./chunk-H6WGMG2T.js";
+
+// src/tools/create-agent.ts
+async function handleCreateAgent(params) {
+  const agent = await createAgent({
+    name: params.name,
+    type: params.type,
+    config: params.config ?? {}
+  });
+  return `Agent created successfully!
+
+**Name**: ${agent.name}
+**ID**: ${agent.id}
+**Type**: ${agent.type}`;
+}
+export {
+  handleCreateAgent
+};
+//# sourceMappingURL=create-agent-S5ZBCEFT.js.map