@anvia/core 0.26.0 → 1.0.0-rc.2

package/dist/chunk-EINTGEGY.js

@@ -0,0 +1,629 @@
+import {
+  isRecord
+} from "./chunk-CQNNSZPG.js";
+import {
+  ToolOutput
+} from "./chunk-77AIYARB.js";
+import {
+  abortError,
+  throwIfAborted
+} from "./chunk-FN7HLLAZ.js";
+
+// src/mcp/client.ts
+import { readFileSync } from "fs";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+// src/mcp/abort.ts
+function linkAbortSignal(source, target) {
+  if (source === void 0) {
+    return () => void 0;
+  }
+  if (source.aborted) {
+    target.abort(source.reason);
+    return () => void 0;
+  }
+  const onAbort = () => target.abort(source.reason);
+  source.addEventListener("abort", onAbort, { once: true });
+  return () => source.removeEventListener("abort", onAbort);
+}
+
+// src/mcp/result.ts
+function createCallToolParams(name, args) {
+  if (args === null || args === void 0) {
+    return { name };
+  }
+  if (!isRecord(args)) {
+    throw new Error("MCP tool arguments must be a JSON object");
+  }
+  return { name, arguments: args };
+}
+function mapMcpToolResult(result) {
+  if ("toolResult" in result) {
+    return [{ type: "text", text: serializeMcpValue(result.toolResult) }];
+  }
+  if (result.isError === true) {
+    throw new Error(mcpErrorMessage(result.content));
+  }
+  const content = result.content.map(mapMcpContent);
+  if (content.length === 0 && result.structuredContent !== void 0) {
+    content.push({ type: "text", text: serializeMcpValue(result.structuredContent) });
+  }
+  return content;
+}
+function mcpErrorMessage(content) {
+  const text = content.map((item) => item.type === "text" ? item.text : void 0).filter((item) => item !== void 0).join("\n");
+  return text === "" ? "MCP tool returned an error" : text;
+}
+function mapMcpContent(content) {
+  if (content.type === "text") {
+    return { type: "text", text: content.text };
+  }
+  if (content.type === "image") {
+    return {
+      type: "file",
+      data: { type: "data", data: content.data },
+      mediaType: content.mimeType
+    };
+  }
+  if (content.type === "resource") {
+    return { type: "text", text: serializeResource(content.resource) };
+  }
+  if (content.type === "audio") {
+    throw new Error(`Unsupported MCP tool result content type: audio (${content.mimeType})`);
+  }
+  throw new Error(`Unsupported MCP tool result content type: resource_link (${content.uri})`);
+}
+function serializeResource(resource) {
+  const mediaType = resource.mimeType ?? ("text" in resource ? "text/plain" : "application/octet-stream");
+  const encoding = "text" in resource ? "text" : "base64";
+  const data = "text" in resource ? resource.text : resource.blob;
+  return `MCP resource (${resource.uri}; ${mediaType}; ${encoding})
+${data}`;
+}
+function serializeMcpValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  let serialized;
+  try {
+    serialized = JSON.stringify(value);
+  } catch (error) {
+    throw new TypeError("MCP tool results must be JSON-serializable.", { cause: error });
+  }
+  if (serialized === void 0) {
+    throw new TypeError("MCP tool results must be JSON-serializable.");
+  }
+  return serialized;
+}
+
+// src/mcp/tool.ts
+function createMcpTool(options) {
+  const { definition, client, serverName, prefix = "" } = options;
+  const exposedName = `${prefix}${definition.name}`;
+  const provenance = Object.freeze({
+    serverName,
+    remoteName: definition.name
+  });
+  const toolDefinition = Object.freeze({
+    name: exposedName,
+    description: definition.description ?? "",
+    parameters: deepFreeze(structuredClone(definition.inputSchema))
+  });
+  const tool = {
+    name: exposedName,
+    mcp: provenance,
+    definition() {
+      return toolDefinition;
+    },
+    async call(args, context) {
+      const result = await client.callTool(
+        createCallToolParams(definition.name, args),
+        void 0,
+        context?.abortSignal === void 0 ? {} : { signal: context.abortSignal }
+      );
+      return ToolOutput.content(mapMcpToolResult(result));
+    }
+  };
+  return Object.freeze(tool);
+}
+function isMcpTool(tool) {
+  if (typeof tool !== "object" || tool === null || !("mcp" in tool)) {
+    return false;
+  }
+  const mcp = tool.mcp;
+  return typeof mcp === "object" && mcp !== null && "serverName" in mcp && typeof mcp.serverName === "string" && mcp.serverName.length > 0 && "remoteName" in mcp && typeof mcp.remoteName === "string" && mcp.remoteName.length > 0;
+}
+function deepFreeze(value) {
+  if (typeof value !== "object" || value === null || Object.isFrozen(value)) {
+    return value;
+  }
+  for (const child of Object.values(value)) {
+    deepFreeze(child);
+  }
+  return Object.freeze(value);
+}
+
+// src/mcp/url-safety.ts
+import { lookup } from "dns/promises";
+import { BlockList, isIP } from "net";
+import { Agent, Pool, fetch as undiciFetch } from "undici";
+var blockedIpv4Addresses = new BlockList();
+var blockedIpv6Addresses = new BlockList();
+for (const [network, prefix] of [
+  ["0.0.0.0", 8],
+  ["10.0.0.0", 8],
+  ["100.64.0.0", 10],
+  ["127.0.0.0", 8],
+  ["169.254.0.0", 16],
+  ["172.16.0.0", 12],
+  ["192.0.0.0", 24],
+  ["192.0.2.0", 24],
+  ["192.88.99.0", 24],
+  ["192.168.0.0", 16],
+  ["198.18.0.0", 15],
+  ["198.51.100.0", 24],
+  ["203.0.113.0", 24],
+  ["224.0.0.0", 4],
+  ["240.0.0.0", 4]
+]) {
+  blockedIpv4Addresses.addSubnet(network, prefix, "ipv4");
+}
+for (const [network, prefix] of [
+  ["::", 96],
+  ["::ffff:0:0", 96],
+  ["64:ff9b::", 96],
+  ["64:ff9b:1::", 48],
+  ["100::", 64],
+  ["2001::", 32],
+  ["2001:2::", 48],
+  ["2001:10::", 28],
+  ["2001:20::", 28],
+  ["2001:db8::", 32],
+  ["2002::", 16],
+  ["fc00::", 7],
+  ["fe80::", 10],
+  ["fec0::", 10],
+  ["ff00::", 8]
+]) {
+  blockedIpv6Addresses.addSubnet(network, prefix, "ipv6");
+}
+var defaultAddressResolver = (hostname) => lookup(hostname, { all: true, verbatim: true });
+function parseAndValidateMcpUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(`Invalid MCP URL: ${url}`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(`MCP URL blocked: only HTTP(S) URLs are allowed (${parsed.protocol})`);
+  }
+  validateMcpHostname(parsed.hostname);
+  return parsed;
+}
+async function resolveAndValidateMcpHostname(hostname, resolveAddresses = defaultAddressResolver) {
+  const normalizedHostname = normalizeHostname(hostname);
+  validateMcpHostname(normalizedHostname);
+  const family = isIP(normalizedHostname);
+  if (family !== 0) {
+    return [{ address: normalizedHostname, family }];
+  }
+  let addresses;
+  try {
+    addresses = await resolveAddresses(normalizedHostname);
+  } catch (cause) {
+    throw new Error(`Unable to resolve MCP URL hostname (${normalizedHostname})`, { cause });
+  }
+  if (addresses.length === 0) {
+    throw new Error(`Unable to resolve MCP URL hostname (${normalizedHostname})`);
+  }
+  for (const { address } of addresses) {
+    validateMcpHostname(address);
+  }
+  return addresses;
+}
+function createSafeMcpLookup(resolveAddresses = defaultAddressResolver) {
+  return (hostname, options, callback) => {
+    void resolveAndValidateMcpHostname(hostname, resolveAddresses).then(
+      (addresses) => {
+        const requestedFamily = normalizeRequestedFamily(options.family);
+        const matchingAddresses = requestedFamily === 0 ? addresses : addresses.filter(({ family }) => family === requestedFamily);
+        if (matchingAddresses.length === 0) {
+          const error = new Error(`No matching address family for MCP URL (${hostname})`);
+          Object.assign(error, { code: "EAI_ADDRFAMILY" });
+          callback(error, []);
+          return;
+        }
+        if (options.all) {
+          callback(null, matchingAddresses);
+          return;
+        }
+        const address = matchingAddresses[0];
+        if (!address) {
+          callback(new Error(`Unable to resolve MCP URL hostname (${hostname})`), []);
+          return;
+        }
+        callback(null, address.address, address.family);
+      },
+      (cause) => {
+        callback(asError(cause), []);
+      }
+    );
+  };
+}
+function createSafeMcpFetch() {
+  return (url, init) => {
+    parseAndValidateMcpUrl(url);
+    return undiciFetch(url, {
+      ...init,
+      dispatcher: safeMcpDispatcher
+    });
+  };
+}
+function validateMcpHostname(hostname) {
+  const normalizedHostname = normalizeHostname(hostname);
+  if (normalizedHostname === "localhost" || normalizedHostname.endsWith(".localhost")) {
+    throw new Error(`MCP URL blocked: localhost not allowed (${normalizedHostname})`);
+  }
+  const family = isIP(normalizedHostname);
+  if (family === 0) {
+    return;
+  }
+  if (family === 4 && normalizedHostname.startsWith("127.") || family === 6 && normalizedHostname === "::1") {
+    throw new Error(`MCP URL blocked: localhost not allowed (${normalizedHostname})`);
+  }
+  if (normalizedHostname === "169.254.169.254" || normalizedHostname === "fd00:ec2::254") {
+    throw new Error(`MCP URL blocked: cloud metadata endpoint not allowed (${normalizedHostname})`);
+  }
+  if (family === 4 && blockedIpv4Addresses.check(normalizedHostname, "ipv4") || family === 6 && blockedIpv6Addresses.check(normalizedHostname, "ipv6")) {
+    const range = family === 4 ? "IP" : "IPv6";
+    throw new Error(`MCP URL blocked: private ${range} range not allowed (${normalizedHostname})`);
+  }
+}
+function normalizeHostname(hostname) {
+  const withoutBrackets = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+  return withoutBrackets.toLowerCase().replace(/\.+$/, "");
+}
+function normalizeRequestedFamily(family) {
+  if (family === 4 || family === "IPv4") {
+    return 4;
+  }
+  if (family === 6 || family === "IPv6") {
+    return 6;
+  }
+  return 0;
+}
+function asError(cause) {
+  return cause instanceof Error ? cause : new Error(String(cause));
+}
+var safeMcpDispatcher = new Agent({
+  autoSelectFamily: true,
+  connect: {
+    lookup: createSafeMcpLookup()
+  },
+  factory(origin, options) {
+    parseAndValidateMcpUrl(origin);
+    return new Pool(origin, options);
+  }
+});
+
+// src/mcp/client.ts
+var coreClientVersion;
+var McpClient = class {
+  name;
+  #options;
+  #closed = false;
+  #connectAbortController;
+  #connecting;
+  #resource;
+  #server;
+  constructor(options) {
+    if (options.name.trim() === "") {
+      throw new TypeError("MCP client name must not be empty");
+    }
+    this.name = options.name;
+    this.#options = options;
+  }
+  connect(options = {}) {
+    if (this.#closed) {
+      return Promise.reject(new Error(`MCP client "${this.name}" is closed`));
+    }
+    if (this.#server !== void 0) {
+      return Promise.resolve(this.#server);
+    }
+    if (this.#connecting !== void 0) {
+      return this.#connecting;
+    }
+    if (options.abortSignal?.aborted === true) {
+      return Promise.reject(abortError(options.abortSignal.reason));
+    }
+    const abortController = new AbortController();
+    const unlinkAbortSignal = linkAbortSignal(options.abortSignal, abortController);
+    this.#connectAbortController = abortController;
+    const connecting = this.#initialize(abortController.signal);
+    this.#connecting = connecting;
+    const clearConnecting = () => {
+      unlinkAbortSignal();
+      if (this.#connecting === connecting) {
+        this.#connecting = void 0;
+      }
+      if (this.#connectAbortController === abortController) {
+        this.#connectAbortController = void 0;
+      }
+    };
+    void connecting.then(clearConnecting, clearConnecting);
+    return connecting;
+  }
+  async close() {
+    this.#closed = true;
+    this.#connectAbortController?.abort(
+      abortError(new Error(`MCP client "${this.name}" was closed during connection`))
+    );
+    const resource = this.#resource;
+    if (resource !== void 0) {
+      await closeResource(resource);
+    }
+  }
+  async #initialize(abortSignal) {
+    const client = createSdkClient();
+    const resource = { client };
+    this.#resource = resource;
+    try {
+      throwIfAborted(abortSignal);
+      const transport = await createTransport(this.#options, { abortSignal });
+      throwIfAborted(abortSignal);
+      await client.connect(transport, requestOptions(abortSignal));
+      throwIfAborted(abortSignal);
+      const definitions = await listAllTools(client, abortSignal);
+      throwIfAborted(abortSignal);
+      const tools = definitions.map(
+        (definition) => createMcpTool({
+          definition,
+          client,
+          serverName: this.name,
+          prefix: this.#options.tools?.prefix
+        })
+      );
+      assertUniqueToolNames(tools, this.name);
+      if (this.#closed) {
+        throw new Error(`MCP client "${this.name}" was closed during connection`);
+      }
+      const serverInfo = copyServerInfo(client.getServerVersion());
+      const capabilities = copyJsonObject(client.getServerCapabilities());
+      const instructions = client.getInstructions();
+      const server = freezeServer({
+        name: this.name,
+        tools,
+        ...serverInfo === void 0 ? {} : { serverInfo },
+        ...capabilities === void 0 ? {} : { capabilities },
+        ...instructions === void 0 ? {} : { instructions }
+      });
+      this.#server = server;
+      return server;
+    } catch (error) {
+      try {
+        await closeResource(resource);
+      } catch {
+      }
+      if (this.#resource === resource) {
+        this.#resource = void 0;
+      }
+      this.#server = void 0;
+      throw error;
+    }
+  }
+};
+async function createTransport(options, connectOptions) {
+  const transport = options.transport;
+  if (transport.type === "custom") {
+    return transport.create({ abortSignal: connectOptions.abortSignal });
+  }
+  if (transport.type === "stdio") {
+    return new StdioClientTransport({
+      command: transport.command,
+      ...transport.args === void 0 ? {} : { args: transport.args },
+      ...transport.env === void 0 ? {} : { env: transport.env },
+      ...transport.cwd === void 0 ? {} : { cwd: transport.cwd },
+      ...transport.stderr === void 0 ? {} : { stderr: transport.stderr },
+      ...transport.maxBufferSize === void 0 ? {} : { maxBufferSize: transport.maxBufferSize }
+    });
+  }
+  return asSdkTransport(
+    new StreamableHTTPClientTransport(parseAndValidateMcpUrl(transport.url), {
+      ...transport.requestInit === void 0 ? {} : { requestInit: transport.requestInit },
+      ...transport.authProvider === void 0 ? {} : { authProvider: transport.authProvider },
+      ...transport.reconnectionOptions === void 0 ? {} : { reconnectionOptions: transport.reconnectionOptions },
+      ...transport.sessionId === void 0 ? {} : { sessionId: transport.sessionId },
+      fetch: createSafeMcpFetch()
+    })
+  );
+}
+async function listAllTools(client, abortSignal) {
+  const tools = [];
+  const seenCursors = /* @__PURE__ */ new Set();
+  let cursor;
+  do {
+    const page = await client.listTools(
+      cursor === void 0 ? void 0 : { cursor },
+      requestOptions(abortSignal)
+    );
+    tools.push(...page.tools);
+    cursor = page.nextCursor;
+    if (cursor !== void 0 && seenCursors.has(cursor)) {
+      throw new Error(`MCP server returned a repeated tools cursor: ${cursor}`);
+    }
+    if (cursor !== void 0) {
+      seenCursors.add(cursor);
+    }
+  } while (cursor !== void 0);
+  return tools;
+}
+function assertUniqueToolNames(tools, serverName) {
+  const names = /* @__PURE__ */ new Set();
+  for (const tool of tools) {
+    if (names.has(tool.name)) {
+      throw new Error(`Duplicate MCP tool name "${tool.name}" from server "${serverName}"`);
+    }
+    names.add(tool.name);
+  }
+}
+function createSdkClient() {
+  return new Client({
+    name: "@anvia/core",
+    version: getCoreClientVersion()
+  });
+}
+function getCoreClientVersion() {
+  if (coreClientVersion === void 0) {
+    coreClientVersion = readCorePackageVersion();
+  }
+  return coreClientVersion;
+}
+function requestOptions(signal) {
+  return signal === void 0 ? {} : { signal };
+}
+function asSdkTransport(transport) {
+  return transport;
+}
+function closeResource(resource) {
+  resource.closePromise ??= resource.client.close();
+  return resource.closePromise;
+}
+function readCorePackageVersion() {
+  try {
+    const packageJson = JSON.parse(
+      readFileSync(new URL("../../package.json", import.meta.url), "utf8")
+    );
+    return typeof packageJson.version === "string" ? packageJson.version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function copyServerInfo(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return deepFreeze2(structuredClone(value));
+}
+function copyJsonObject(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return deepFreeze2(structuredClone(value));
+}
+function freezeServer(server) {
+  Object.freeze(server.tools);
+  return Object.freeze(server);
+}
+function deepFreeze2(value) {
+  if (typeof value !== "object" || value === null || Object.isFrozen(value)) {
+    return value;
+  }
+  for (const child of Object.values(value)) {
+    deepFreeze2(child);
+  }
+  return Object.freeze(value);
+}
+
+// src/mcp/client-group.ts
+var McpClientGroup = class _McpClientGroup {
+  clients;
+  servers;
+  #closePromise;
+  constructor(clients, servers) {
+    this.clients = Object.freeze([...clients]);
+    this.servers = Object.freeze([...servers]);
+  }
+  static async connect(options) {
+    const clients = [...options.clients];
+    assertUniqueClientNames(clients);
+    const abortController = new AbortController();
+    const unlinkAbortSignal = linkAbortSignal(options.abortSignal, abortController);
+    let firstConnectionFailure;
+    let connectionFailed = false;
+    const connections = clients.map(
+      (client) => client.connect({ abortSignal: abortController.signal }).catch((error) => {
+        if (!connectionFailed) {
+          connectionFailed = true;
+          firstConnectionFailure = error;
+          abortController.abort(error);
+        }
+        throw error;
+      })
+    );
+    const settled = await Promise.allSettled(connections).finally(unlinkAbortSignal);
+    const firstFailure = settled.find(
+      (result) => result.status === "rejected"
+    );
+    if (firstFailure !== void 0) {
+      await rollbackSuccessfulClients(clients, settled);
+      throw connectionFailed ? firstConnectionFailure : firstFailure.reason;
+    }
+    const servers = settled.map((result) => result.value);
+    try {
+      assertUniqueServerAndToolNames(servers);
+    } catch (error) {
+      try {
+        await closeAll(clients);
+      } catch {
+      }
+      throw error;
+    }
+    return new _McpClientGroup(clients, servers);
+  }
+  close() {
+    this.#closePromise ??= closeAll(this.clients);
+    return this.#closePromise;
+  }
+};
+function assertUniqueClientNames(clients) {
+  const names = /* @__PURE__ */ new Set();
+  for (const client of clients) {
+    if (names.has(client.name)) {
+      throw new Error(`Duplicate MCP client name "${client.name}"`);
+    }
+    names.add(client.name);
+  }
+}
+function assertUniqueServerAndToolNames(servers) {
+  const serverNames = /* @__PURE__ */ new Set();
+  const toolNames = /* @__PURE__ */ new Map();
+  for (const server of servers) {
+    if (serverNames.has(server.name)) {
+      throw new Error(`Duplicate MCP server name "${server.name}"`);
+    }
+    serverNames.add(server.name);
+    for (const tool of server.tools) {
+      const existing = toolNames.get(tool.name);
+      if (existing !== void 0) {
+        throw new Error(
+          `Duplicate MCP tool name "${tool.name}" from servers "${existing}" and "${server.name}"`
+        );
+      }
+      toolNames.set(tool.name, server.name);
+    }
+  }
+}
+async function rollbackSuccessfulClients(clients, settled) {
+  const successful = clients.filter((_, index) => settled[index]?.status === "fulfilled");
+  try {
+    await closeAll(successful);
+  } catch {
+  }
+}
+async function closeAll(clients) {
+  const settled = await Promise.allSettled(clients.map((client) => client.close()));
+  const errors = settled.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+  if (errors.length > 0) {
+    throw new AggregateError(errors, "Failed to close one or more MCP clients");
+  }
+}
+
+export {
+  isMcpTool,
+  McpClient,
+  McpClientGroup
+};
+//# sourceMappingURL=chunk-EINTGEGY.js.map