@anvia/core 1.0.0-rc.9 → 1.0.0

package/dist/chunk-76JLMBVT.js

@@ -1,716 +0,0 @@
-import {
-  ToolOutput
-} from "./chunk-EMZKPRE6.js";
-import {
-  isJsonValue
-} from "./chunk-3XQGVDU5.js";
-import {
-  abortError,
-  throwIfAborted
-} from "./chunk-3RWESPUG.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 === void 0) {
-    return { name };
-  }
-  return { name, arguments: parseMcpToolArguments(args) };
-}
-function parseMcpToolArguments(args) {
-  if (!isMcpJsonObject(args)) {
-    throw new TypeError("MCP tool arguments must be a strict JSON object");
-  }
-  return args;
-}
-function isMcpJsonObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && isJsonValue(value);
-}
-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;
-  }
-  if (!isJsonValue(value)) {
-    throw new TypeError("MCP tool results must be strict JSON values.");
-  }
-  let serialized;
-  try {
-    serialized = JSON.stringify(value);
-  } catch (error) {
-    throw new TypeError("MCP tool results must be strict JSON values.", { cause: error });
-  }
-  if (serialized === void 0) {
-    throw new TypeError("MCP tool results must be strict JSON values.");
-  }
-  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;
-    },
-    parseInput(args) {
-      return parseMcpToolArguments(args);
-    },
-    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) {
-  const parsed = parseMcpHttpUrl(url);
-  validateMcpHostname(parsed.hostname);
-  return parsed;
-}
-function parseMcpHttpUrl(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})`);
-  }
-  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 transportOwnedHttpHeaders = /* @__PURE__ */ new Set([
-  "accept",
-  "content-type",
-  "last-event-id",
-  "mcp-protocol-version",
-  "mcp-session-id"
-]);
-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();
-      let registration = {
-        name: this.name,
-        tools
-      };
-      if (serverInfo !== void 0) registration = { ...registration, serverInfo };
-      if (capabilities !== void 0) registration = { ...registration, capabilities };
-      if (instructions !== void 0) registration = { ...registration, instructions };
-      const server = freezeServer(registration);
-      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") {
-    let parameters2 = {
-      command: transport.command
-    };
-    if (transport.args !== void 0) parameters2 = { ...parameters2, args: transport.args };
-    if (transport.env !== void 0) parameters2 = { ...parameters2, env: transport.env };
-    if (transport.cwd !== void 0) parameters2 = { ...parameters2, cwd: transport.cwd };
-    if (transport.stderr !== void 0) parameters2 = { ...parameters2, stderr: transport.stderr };
-    if (transport.maxBufferSize !== void 0) {
-      parameters2 = { ...parameters2, maxBufferSize: transport.maxBufferSize };
-    }
-    return new StdioClientTransport(parameters2);
-  }
-  const ssrfProtection = transport.ssrfProtection ?? "strict";
-  if (ssrfProtection !== "strict" && ssrfProtection !== "disabled") {
-    throw new TypeError("MCP Streamable HTTP ssrfProtection must be strict or disabled");
-  }
-  let parameters = {};
-  let url;
-  let transportFetch;
-  if (ssrfProtection === "strict") {
-    transportFetch = createSafeMcpFetch();
-    url = parseAndValidateMcpUrl(transport.url);
-  } else {
-    url = parseMcpHttpUrl(transport.url);
-  }
-  if (transport.headers !== void 0) {
-    const headers = copyMcpHeaders(transport.headers, transport.authProvider !== void 0);
-    const fetchRequest = transportFetch ?? defaultMcpFetch;
-    transportFetch = createMcpEndpointFetch(url, headers, fetchRequest);
-  }
-  if (transportFetch !== void 0) parameters = { ...parameters, fetch: transportFetch };
-  if (transport.authProvider !== void 0) {
-    parameters = { ...parameters, authProvider: transport.authProvider };
-  }
-  if (transport.reconnectionOptions !== void 0) {
-    parameters = { ...parameters, reconnectionOptions: transport.reconnectionOptions };
-  }
-  if (transport.sessionId !== void 0) {
-    parameters = { ...parameters, sessionId: transport.sessionId };
-  }
-  return asSdkTransport(new StreamableHTTPClientTransport(url, parameters));
-}
-function copyMcpHeaders(value, hasAuthProvider) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new TypeError("MCP Streamable HTTP headers must be a plain object");
-  }
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype !== Object.prototype && prototype !== null) {
-    throw new TypeError("MCP Streamable HTTP headers must be a plain object");
-  }
-  const headers = new Headers();
-  for (const [name, headerValue] of Object.entries(value)) {
-    if (typeof headerValue !== "string") {
-      throw new TypeError(`MCP Streamable HTTP header ${name} must be a string`);
-    }
-    const normalizedName = name.toLowerCase();
-    if (transportOwnedHttpHeaders.has(normalizedName)) {
-      throw new TypeError(`MCP Streamable HTTP header ${name} is owned by the transport`);
-    }
-    if (hasAuthProvider && normalizedName === "authorization") {
-      throw new TypeError(
-        "MCP Streamable HTTP authorization header cannot be combined with authProvider"
-      );
-    }
-    headers.set(name, headerValue);
-  }
-  return headers;
-}
-function createMcpEndpointFetch(endpoint, configuredHeaders, fetchRequest) {
-  return (input, init) => {
-    const requestUrl = input instanceof Request ? new URL(input.url) : new URL(input);
-    if (requestUrl.href !== endpoint.href) return fetchRequest(input, init);
-    const requestHeaders = new Headers(
-      init?.headers ?? (input instanceof Request ? input.headers : void 0)
-    );
-    configuredHeaders.forEach((value, name) => {
-      requestHeaders.set(name, value);
-    });
-    return fetchRequest(input, { ...init, headers: requestHeaders, redirect: "error" });
-  };
-}
-var defaultMcpFetch = (input, init) => globalThis.fetch(input, init);
-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-76JLMBVT.js.map