@within-7/minto 0.4.1 → 0.4.3

package/dist/services/mcpClient.js

@@ -1,921 +0,0 @@
-import { zipObject } from "lodash-es";
-import { debug as debugLogger } from "../utils/debugLogger.js";
-import {
-  getCurrentProjectConfig,
-  saveCurrentProjectConfig,
-  getGlobalConfig,
-  saveGlobalConfig,
-  getMcprcConfig,
-  addMcprcServerForTesting,
-  removeMcprcServerForTesting
-} from "../utils/config.js";
-import { existsSync, readFileSync, writeFileSync } from "fs";
-import { join } from "path";
-import { getCwd } from "../utils/state.js";
-import { safeParseJSON } from "../utils/json.js";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import {
-  CallToolResultSchema,
-  ListPromptsResultSchema,
-  ListToolsResultSchema,
-  ListResourcesResultSchema,
-  ReadResourceResultSchema,
-  ToolListChangedNotificationSchema
-} from "@modelcontextprotocol/sdk/types.js";
-import { memoize, pickBy } from "lodash-es";
-import { MCPTool } from "../tools/MCPTool/MCPTool.js";
-import { logMCPError } from "../utils/log.js";
-import { ensureProxyBypass } from "../utils/envConfig.js";
-import { PRODUCT_COMMAND } from "../constants/product.js";
-import { CircuitBreakerRegistry, CircuitOpenError } from "../utils/CircuitBreaker.js";
-import { emitReminderEvent } from "./systemReminder.js";
-const SENSITIVE_ENV_PREFIXES = [
-  "ANTHROPIC_",
-  "OPENAI_",
-  "AWS_SECRET",
-  "GITHUB_TOKEN",
-  "GH_TOKEN",
-  "MINTO_API"
-];
-function filterSensitiveEnv(env) {
-  return Object.fromEntries(
-    Object.entries(env).filter(
-      ([k]) => !SENSITIVE_ENV_PREFIXES.some((p) => k.startsWith(p) || k === p)
-    ).filter((e) => e[1] !== void 0)
-  );
-}
-const mcpCircuitBreakers = new CircuitBreakerRegistry({
-  failureThreshold: 5,
-  successThreshold: 2,
-  openTimeout: 3e4
-  // 30 seconds before trying again
-});
-function parseEnvVars(rawEnvArgs) {
-  const parsedEnv = {};
-  if (rawEnvArgs) {
-    for (const envStr of rawEnvArgs) {
-      const [key, ...valueParts] = envStr.split("=");
-      if (!key || valueParts.length === 0) {
-        throw new Error(
-          `Invalid environment variable format: ${envStr}, environment variables should be added as: -e KEY1=value1 -e KEY2=value2`
-        );
-      }
-      parsedEnv[key] = valueParts.join("=");
-    }
-  }
-  return parsedEnv;
-}
-const VALID_SCOPES = ["project", "global", "mcprc"];
-const EXTERNAL_SCOPES = ["project", "global"];
-function ensureConfigScope(scope) {
-  if (!scope) return "project";
-  const scopesToCheck = process.env.USER_TYPE === "external" ? EXTERNAL_SCOPES : VALID_SCOPES;
-  if (!scopesToCheck.includes(scope)) {
-    throw new Error(
-      `Invalid scope: ${scope}. Must be one of: ${scopesToCheck.join(", ")}`
-    );
-  }
-  return scope;
-}
-function addMcpServer(name, server, scope = "project") {
-  if (scope === "mcprc") {
-    if (process.env.NODE_ENV === "test") {
-      addMcprcServerForTesting(name, server);
-    } else {
-      const mcprcPath = join(getCwd(), ".mcprc");
-      let mcprcConfig = {};
-      if (existsSync(mcprcPath)) {
-        try {
-          const mcprcContent = readFileSync(mcprcPath, "utf-8");
-          const existingConfig = safeParseJSON(mcprcContent);
-          if (existingConfig && typeof existingConfig === "object") {
-            mcprcConfig = existingConfig;
-          }
-        } catch (e) {
-          debugLogger.warn(
-            "MCP_CONFIG",
-            `Failed to read/parse .mcprc: ${e instanceof Error ? e.message : String(e)}`
-          );
-        }
-      }
-      mcprcConfig[name] = server;
-      try {
-        writeFileSync(mcprcPath, JSON.stringify(mcprcConfig, null, 2), "utf-8");
-      } catch (error) {
-        throw new Error(`Failed to write to .mcprc: ${error}`);
-      }
-    }
-  } else if (scope === "global") {
-    const config = getGlobalConfig();
-    if (!config.mcpServers) {
-      config.mcpServers = {};
-    }
-    config.mcpServers[name] = server;
-    saveGlobalConfig(config);
-  } else {
-    const config = getCurrentProjectConfig();
-    if (!config.mcpServers) {
-      config.mcpServers = {};
-    }
-    config.mcpServers[name] = server;
-    saveCurrentProjectConfig(config);
-  }
-}
-function removeMcpServer(name, scope = "project") {
-  if (scope === "mcprc") {
-    if (process.env.NODE_ENV === "test") {
-      removeMcprcServerForTesting(name);
-    } else {
-      const mcprcPath = join(getCwd(), ".mcprc");
-      if (!existsSync(mcprcPath)) {
-        throw new Error("No .mcprc file found in this directory");
-      }
-      try {
-        const mcprcContent = readFileSync(mcprcPath, "utf-8");
-        const mcprcConfig = safeParseJSON(mcprcContent);
-        if (!mcprcConfig || typeof mcprcConfig !== "object" || !mcprcConfig[name]) {
-          throw new Error(`No MCP server found with name: ${name} in .mcprc`);
-        }
-        delete mcprcConfig[name];
-        writeFileSync(mcprcPath, JSON.stringify(mcprcConfig, null, 2), "utf-8");
-      } catch (error) {
-        if (error instanceof Error) {
-          throw error;
-        }
-        throw new Error(`Failed to remove from .mcprc: ${error}`);
-      }
-    }
-  } else if (scope === "global") {
-    const config = getGlobalConfig();
-    if (!config.mcpServers?.[name]) {
-      throw new Error(`No global MCP server found with name: ${name}`);
-    }
-    delete config.mcpServers[name];
-    saveGlobalConfig(config);
-  } else {
-    const config = getCurrentProjectConfig();
-    if (!config.mcpServers?.[name]) {
-      throw new Error(`No local MCP server found with name: ${name}`);
-    }
-    delete config.mcpServers[name];
-    saveCurrentProjectConfig(config);
-  }
-}
-function listMCPServers() {
-  const globalConfig = getGlobalConfig();
-  const mcprcConfig = getMcprcConfig();
-  const projectConfig = getCurrentProjectConfig();
-  return {
-    ...globalConfig.mcpServers ?? {},
-    ...mcprcConfig ?? {},
-    // mcprc configs override global ones
-    ...projectConfig.mcpServers ?? {}
-    // Project configs override mcprc ones
-  };
-}
-function getMcpServer(name) {
-  const projectConfig = getCurrentProjectConfig();
-  const mcprcConfig = getMcprcConfig();
-  const globalConfig = getGlobalConfig();
-  if (projectConfig.mcpServers?.[name]) {
-    return { ...projectConfig.mcpServers[name], scope: "project" };
-  }
-  if (mcprcConfig?.[name]) {
-    return { ...mcprcConfig[name], scope: "mcprc" };
-  }
-  if (globalConfig.mcpServers?.[name]) {
-    return { ...globalConfig.mcpServers[name], scope: "global" };
-  }
-  return void 0;
-}
-async function connectToServer(name, serverRef) {
-  let transport;
-  if (serverRef.type === "http") {
-    const { StreamableHTTPClientTransport } = await import("@modelcontextprotocol/sdk/client/streamableHttp.js");
-    transport = new StreamableHTTPClientTransport(
-      new URL(serverRef.url),
-      {
-        // Pass headers but never log sensitive values
-        requestInit: serverRef.headers ? { headers: serverRef.headers } : void 0
-      }
-    );
-  } else if (serverRef.type === "sse") {
-    transport = new SSEClientTransport(new URL(serverRef.url));
-  } else {
-    transport = new StdioClientTransport({
-      command: serverRef.command,
-      args: serverRef.args,
-      env: ensureProxyBypass({
-        ...filterSensitiveEnv(process.env),
-        ...serverRef.env
-      }),
-      stderr: "pipe"
-      // prevents error output from the MCP server from printing to the UI
-    });
-  }
-  const client = new Client(
-    {
-      name: PRODUCT_COMMAND,
-      version: "0.1.0"
-    },
-    {
-      capabilities: {}
-    }
-  );
-  const connectionTimeout = poolConfig.connectionTimeout;
-  const connectPromise = client.connect(transport);
-  const timeoutPromise = new Promise((_, reject) => {
-    const timeoutId = setTimeout(() => {
-      reject(
-        new Error(
-          `Connection to MCP server "${name}" timed out after ${connectionTimeout}ms`
-        )
-      );
-    }, connectionTimeout);
-    connectPromise.then(
-      () => clearTimeout(timeoutId),
-      () => clearTimeout(timeoutId)
-    );
-  });
-  await Promise.race([connectPromise, timeoutPromise]);
-  if (serverRef.type === "stdio") {
-    ;
-    transport.stderr?.on("data", (data) => {
-      const errorText = data.toString().trim();
-      if (errorText) {
-        logMCPError(name, `Server stderr: ${errorText}`);
-      }
-    });
-  }
-  client.setNotificationHandler(ToolListChangedNotificationSchema, async () => {
-    if (typeof getMCPTools.cache?.clear === "function") {
-      getMCPTools.cache.clear();
-    }
-  });
-  return client;
-}
-function getMcprcServerStatus(serverName) {
-  const config = getCurrentProjectConfig();
-  if (config.approvedMcprcServers?.includes(serverName)) {
-    return "approved";
-  }
-  if (config.rejectedMcprcServers?.includes(serverName)) {
-    return "rejected";
-  }
-  return "pending";
-}
-let connectedClients = [];
-const DEFAULT_POOL_CONFIG = {
-  maxConnections: 10,
-  connectionTimeout: Number(process.env.MCP_TIMEOUT) || 1e4,
-  healthCheckInterval: 3e4,
-  retryFailed: true,
-  maxRetries: 2,
-  maxOutputChars: Number(process.env.MAX_MCP_OUTPUT_CHARS) || 25e3
-};
-let poolConfig = { ...DEFAULT_POOL_CONFIG };
-let healthCheckTimer = null;
-let connectionLock = null;
-let pendingRefresh = false;
-async function acquireConnectionLock() {
-  while (connectionLock) {
-    await connectionLock;
-  }
-  let release;
-  connectionLock = new Promise((resolve) => {
-    release = () => {
-      connectionLock = null;
-      resolve();
-    };
-  });
-  return release;
-}
-function configureMcpPool(config) {
-  poolConfig = { ...poolConfig, ...config };
-  if (config.healthCheckInterval !== void 0) {
-    stopHealthCheck();
-    if (poolConfig.healthCheckInterval > 0) {
-      startHealthCheck();
-    }
-  }
-}
-function getMcpPoolConfig() {
-  return { ...poolConfig };
-}
-const connectionHealth = /* @__PURE__ */ new Map();
-async function checkConnectionHealth(client) {
-  const startTime = Date.now();
-  try {
-    await client.client.getServerCapabilities();
-    const latencyMs = Date.now() - startTime;
-    return {
-      name: client.name,
-      status: "healthy",
-      lastCheck: Date.now(),
-      latencyMs
-    };
-  } catch (error) {
-    return {
-      name: client.name,
-      status: "unhealthy",
-      lastCheck: Date.now(),
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-async function runHealthCheck() {
-  const clients = await getClients();
-  const healthResults = [];
-  for (const client of clients) {
-    if (client.type === "connected") {
-      const health = await checkConnectionHealth(client);
-      connectionHealth.set(client.name, health);
-      healthResults.push(health);
-    } else {
-      const health = {
-        name: client.name,
-        status: "unhealthy",
-        lastCheck: Date.now(),
-        error: "Connection failed"
-      };
-      connectionHealth.set(client.name, health);
-      healthResults.push(health);
-    }
-  }
-  return healthResults;
-}
-function getConnectionHealth() {
-  return Array.from(connectionHealth.values());
-}
-function getServerHealth(serverName) {
-  return connectionHealth.get(serverName) || null;
-}
-function getServerCircuitBreaker(serverName) {
-  return mcpCircuitBreakers.getOrCreate(serverName);
-}
-function getAllCircuitBreakerStats() {
-  const stats = {};
-  for (const [name, breaker] of mcpCircuitBreakers.getAll().entries()) {
-    stats[name] = breaker.getStats();
-  }
-  return stats;
-}
-function startHealthCheck() {
-  if (healthCheckTimer) return;
-  if (poolConfig.healthCheckInterval <= 0) return;
-  healthCheckTimer = setInterval(async () => {
-    try {
-      await runHealthCheck();
-    } catch (e) {
-      debugLogger.warn(
-        "MCP_HEALTH",
-        `Health check failed: ${e instanceof Error ? e.message : String(e)}`
-      );
-    }
-  }, poolConfig.healthCheckInterval);
-}
-function stopHealthCheck() {
-  if (healthCheckTimer) {
-    clearInterval(healthCheckTimer);
-    healthCheckTimer = null;
-  }
-}
-function getPoolStats() {
-  const health = getConnectionHealth();
-  return {
-    totalConnections: connectedClients.length,
-    connectedCount: connectedClients.filter((c) => c.type === "connected").length,
-    failedCount: connectedClients.filter((c) => c.type === "failed").length,
-    healthyCount: health.filter((h) => h.status === "healthy").length,
-    unhealthyCount: health.filter((h) => h.status === "unhealthy").length
-  };
-}
-async function connectWithRetry(name, serverRef) {
-  const { retryFailed, maxRetries } = poolConfig;
-  let lastError;
-  const attempts = retryFailed ? maxRetries : 0;
-  for (let attempt = 0; attempt <= attempts; attempt++) {
-    try {
-      return await connectToServer(name, serverRef);
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
-      if (attempt < attempts && retryFailed) {
-        const delay = 1e3 * Math.pow(2, attempt);
-        logMCPError(
-          name,
-          `Connection attempt ${attempt + 1} failed, retrying in ${delay}ms...`
-        );
-        await new Promise((r) => setTimeout(r, delay));
-      }
-    }
-  }
-  throw lastError;
-}
-const getClients = memoize(async () => {
-  if (process.env.CI && process.env.NODE_ENV !== "test") {
-    return [];
-  }
-  const globalServers = getGlobalConfig().mcpServers ?? {};
-  const mcprcServers = getMcprcConfig();
-  const projectServers = getCurrentProjectConfig().mcpServers ?? {};
-  const approvedMcprcServers = pickBy(
-    mcprcServers,
-    (_, name) => getMcprcServerStatus(name) === "approved"
-  );
-  const allServers = {
-    ...globalServers,
-    ...approvedMcprcServers,
-    // Approved .mcprc servers override global ones
-    ...projectServers
-    // Project servers take highest precedence
-  };
-  const enabledServers = pickBy(
-    allServers,
-    (server) => server.enabled !== false
-    // Default to enabled if not specified
-  );
-  const clients = await Promise.all(
-    Object.entries(enabledServers).map(async ([name, serverRef]) => {
-      try {
-        const client = await connectWithRetry(
-          name,
-          serverRef
-        );
-        return { name, client, type: "connected" };
-      } catch (error) {
-        logMCPError(
-          name,
-          `Connection failed: ${error instanceof Error ? error.message : String(error)}`
-        );
-        return { name, type: "failed" };
-      }
-    })
-  );
-  connectedClients = clients;
-  return clients;
-});
-async function requestAll(req, resultSchema, requiredCapability) {
-  const clients = await getClients();
-  const results = await Promise.allSettled(
-    clients.map(async (client) => {
-      if (client.type === "failed") return null;
-      try {
-        const capabilities = await client.client.getServerCapabilities();
-        if (!capabilities?.[requiredCapability]) {
-          return null;
-        }
-        return {
-          client,
-          result: await client.client.request(req, resultSchema)
-        };
-      } catch (error) {
-        if (client.type === "connected") {
-          logMCPError(
-            client.name,
-            `Failed to request '${req.method}': ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-        return null;
-      }
-    })
-  );
-  return results.filter(
-    (result) => result.status === "fulfilled"
-  ).map((result) => result.value).filter(
-    (result) => result !== null
-  );
-}
-function isLazyMCPEnabled() {
-  return !!(process.env.MINTO_ENABLE_TOOL_SEARCH || process.env.ENABLE_TOOL_SEARCH);
-}
-const lazySchemaCache = /* @__PURE__ */ new Map();
-async function getLazyInputSchema(client, toolName, fullName) {
-  if (lazySchemaCache.has(fullName)) {
-    return lazySchemaCache.get(fullName);
-  }
-  try {
-    const result = await client.client.request(
-      { method: "tools/list" },
-      ListToolsResultSchema
-    );
-    for (const tool of result.tools) {
-      const key = "mcp__" + client.name + "__" + tool.name;
-      lazySchemaCache.set(key, tool.inputSchema);
-    }
-    return lazySchemaCache.get(fullName);
-  } catch {
-    return void 0;
-  }
-}
-const getMCPTools = memoize(async () => {
-  const toolsList = await requestAll(
-    {
-      method: "tools/list"
-    },
-    ListToolsResultSchema,
-    "tools"
-  );
-  const lazyMode = isLazyMCPEnabled();
-  return toolsList.flatMap(({ client, result: { tools } }) => {
-    const validTools = tools.filter(
-      (tool) => {
-        if (!tool || typeof tool.name !== "string" || tool.name.length === 0) {
-          logMCPError(
-            `Invalid MCP tool from ${client.name}: missing or invalid name`,
-            new Error("Tool validation failed")
-          );
-          return false;
-        }
-        return true;
-      }
-    );
-    return validTools.map((tool) => {
-      const fullName = "mcp__" + client.name + "__" + tool.name;
-      if (lazyMode) {
-        lazySchemaCache.set(
-          fullName,
-          tool.inputSchema
-        );
-      }
-      return {
-        ...MCPTool,
-        name: fullName,
-        async description() {
-          return tool.description ?? "";
-        },
-        async prompt() {
-          return tool.description ?? "";
-        },
-        // In lazy mode, schema starts as undefined and is loaded on-demand
-        inputJSONSchema: lazyMode ? void 0 : tool.inputSchema,
-        async validateInput(input, context) {
-          return { result: true };
-        },
-        async *call(args, context) {
-          if (lazyMode && !lazySchemaCache.has(fullName)) {
-            await getLazyInputSchema(client, tool.name, fullName);
-          }
-          const data = await callMCPTool({ client, tool: tool.name, args });
-          yield {
-            type: "result",
-            data,
-            resultForAssistant: data
-          };
-        },
-        userFacingName() {
-          return `${client.name}:${tool.name} (MCP)`;
-        }
-      };
-    });
-  });
-});
-async function withTimeout(promise, timeoutMs, operationName) {
-  let timeoutId;
-  const timeoutPromise = new Promise((_, reject) => {
-    timeoutId = setTimeout(() => {
-      reject(
-        new Error(
-          `MCP operation "${operationName}" timed out after ${timeoutMs}ms`
-        )
-      );
-    }, timeoutMs);
-  });
-  try {
-    const result = await Promise.race([promise, timeoutPromise]);
-    if (timeoutId) clearTimeout(timeoutId);
-    return result;
-  } catch (error) {
-    if (timeoutId) clearTimeout(timeoutId);
-    throw error;
-  }
-}
-function isTimeoutError(error) {
-  if (error instanceof Error) {
-    return error.name === "TimeoutError" || error.message.includes("timed out") || error.message.includes("timeout");
-  }
-  if (error instanceof DOMException) {
-    return error.name === "TimeoutError";
-  }
-  return false;
-}
-const MCP_TOOL_TIMEOUT_MS = 12e4;
-const MCP_TOOL_MAX_RETRIES = 2;
-function truncateMcpOutput(text) {
-  const limit = poolConfig.maxOutputChars;
-  if (text.length <= limit) return text;
-  return text.slice(0, limit) + `
-
-[Output truncated: ${text.length} chars exceeded limit of ${limit}]`;
-}
-async function callMCPTool({
-  client: { client, name },
-  tool,
-  args
-}) {
-  const breaker = mcpCircuitBreakers.getOrCreate(name);
-  let lastError;
-  const maxRetries = MCP_TOOL_MAX_RETRIES;
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      const result = await breaker.executeWithTimeout(async () => {
-        const callPromise = client.callTool(
-          {
-            name: tool,
-            arguments: args
-          },
-          CallToolResultSchema
-        );
-        return await withTimeout(
-          callPromise,
-          MCP_TOOL_TIMEOUT_MS,
-          `${name}:${tool}`
-        );
-      }, MCP_TOOL_TIMEOUT_MS);
-      if ("isError" in result && result.isError) {
-        const errorMessage = `Error calling tool ${tool}: ${result.error}`;
-        logMCPError(name, errorMessage);
-        throw Error(errorMessage);
-      }
-      if ("toolResult" in result) {
-        const text = String(result.toolResult);
-        return truncateMcpOutput(text);
-      }
-      if ("content" in result && Array.isArray(result.content)) {
-        return result.content.map((item) => {
-          if (item.type === "image") {
-            return {
-              type: "image",
-              source: {
-                type: "base64",
-                data: String(item.data),
-                media_type: item.mimeType
-              }
-            };
-          }
-          return item;
-        });
-      }
-      throw Error(`Unexpected response format from tool ${tool}`);
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
-      if (lastError instanceof CircuitOpenError) {
-        logMCPError(
-          name,
-          `Circuit breaker is open for server "${name}". ${lastError.message}`
-        );
-        throw lastError;
-      }
-      if (isTimeoutError(error) && attempt < maxRetries) {
-        logMCPError(
-          name,
-          `Tool "${tool}" timed out (attempt ${attempt + 1}/${maxRetries + 1}), retrying...`
-        );
-        await new Promise(
-          (resolve) => setTimeout(resolve, 1e3 * Math.pow(2, attempt))
-        );
-        continue;
-      }
-      if (isTimeoutError(error)) {
-        logMCPError(
-          name,
-          `Tool "${tool}" failed after ${maxRetries + 1} attempts due to timeout`
-        );
-      }
-      throw lastError;
-    }
-  }
-  throw lastError || new Error(`MCP tool ${tool} failed with unknown error`);
-}
-const getMCPCommands = memoize(async () => {
-  const results = await requestAll(
-    {
-      method: "prompts/list"
-    },
-    ListPromptsResultSchema,
-    "prompts"
-  );
-  return results.flatMap(
-    ({ client, result }) => result.prompts?.map((_) => {
-      const argNames = Object.values(_.arguments ?? {}).map((k) => k.name);
-      return {
-        type: "prompt",
-        name: "mcp__" + client.name + "__" + _.name,
-        description: _.description ?? "",
-        isEnabled: true,
-        isHidden: false,
-        progressMessage: "running",
-        userFacingName() {
-          return `${client.name}:${_.name} (MCP)`;
-        },
-        argNames,
-        async getPromptForCommand(args) {
-          const argsArray = args.split(" ");
-          return await runCommand(
-            { name: _.name, client },
-            zipObject(argNames, argsArray)
-          );
-        }
-      };
-    })
-  );
-});
-async function runCommand({ name, client }, args) {
-  try {
-    const result = await client.client.getPrompt({ name, arguments: args });
-    return result.messages.map(
-      (message) => ({
-        role: message.role,
-        content: [
-          message.content.type === "text" ? {
-            type: "text",
-            text: message.content.text
-          } : message.content.type === "resource" ? {
-            type: "text",
-            text: typeof message.content.resource?.text === "string" ? message.content.resource.text : `[MCP Resource: ${message.content.resource?.uri ?? "unknown"}]`
-          } : {
-            type: "image",
-            source: {
-              data: String(message.content.data),
-              media_type: message.content.mimeType,
-              type: "base64"
-            }
-          }
-        ]
-      })
-    );
-  } catch (error) {
-    logMCPError(
-      client.name,
-      `Error running command '${name}': ${error instanceof Error ? error.message : String(error)}`
-    );
-    throw error;
-  }
-}
-function closeClientsInBackground(clients) {
-  const CLOSE_TIMEOUT_MS = 5e3;
-  const closePromises = clients.map(async (wrappedClient) => {
-    if (wrappedClient.type === "connected") {
-      try {
-        await wrappedClient.client.close();
-      } catch (e) {
-        debugLogger.warn(
-          "MCP_CLOSE",
-          `Failed to close MCP client: ${e instanceof Error ? e.message : String(e)}`
-        );
-      }
-    }
-  });
-  Promise.race([
-    Promise.allSettled(closePromises),
-    new Promise((resolve) => setTimeout(resolve, CLOSE_TIMEOUT_MS))
-  ]).catch(() => {
-  });
-}
-async function refreshMCPConnections() {
-  if (pendingRefresh) {
-    return;
-  }
-  pendingRefresh = true;
-  const release = await acquireConnectionLock();
-  try {
-    const oldClients = connectedClients;
-    connectedClients = [];
-    if (typeof getClients.cache?.clear === "function") {
-      getClients.cache.clear();
-    }
-    if (typeof getMCPTools.cache?.clear === "function") {
-      getMCPTools.cache.clear();
-    }
-    if (typeof getMCPCommands.cache?.clear === "function") {
-      getMCPCommands.cache.clear();
-    }
-    mcpCircuitBreakers.resetAll();
-    try {
-      const { invalidateToolsCache } = await import("../tools.js");
-      invalidateToolsCache();
-    } catch {
-    }
-    if (oldClients.length > 0) {
-      closeClientsInBackground(oldClients);
-    }
-  } finally {
-    pendingRefresh = false;
-    release();
-  }
-}
-async function shutdownMCPClients() {
-  if (connectedClients.length === 0) return;
-  const oldClients = connectedClients;
-  connectedClients = [];
-  const SHUTDOWN_TIMEOUT_MS = 3e3;
-  const closePromises = oldClients.map(async (wrappedClient) => {
-    if (wrappedClient.type === "connected") {
-      try {
-        await wrappedClient.client.close();
-      } catch {
-      }
-    }
-  });
-  try {
-    await Promise.race([
-      Promise.allSettled(closePromises),
-      new Promise((resolve) => setTimeout(resolve, SHUTDOWN_TIMEOUT_MS))
-    ]);
-  } catch {
-  }
-  if (typeof getClients.cache?.clear === "function") {
-    getClients.cache.clear();
-  }
-  if (typeof getMCPTools.cache?.clear === "function") {
-    getMCPTools.cache.clear();
-  }
-  if (typeof getMCPCommands.cache?.clear === "function") {
-    getMCPCommands.cache.clear();
-  }
-}
-async function listMCPResources(serverFilter) {
-  const results = await requestAll(
-    {
-      method: "resources/list"
-    },
-    ListResourcesResultSchema,
-    "resources"
-  );
-  return results.filter(({ client }) => !serverFilter || client.name === serverFilter).flatMap(
-    ({ client, result }) => (result.resources || []).map((resource) => ({
-      uri: resource.uri,
-      name: resource.name,
-      description: resource.description,
-      mimeType: resource.mimeType,
-      serverName: client.name
-    }))
-  );
-}
-async function readMCPResource(uri, serverName) {
-  const clients = await getClients();
-  const targetClients = serverName ? clients.filter(
-    (c) => c.type === "connected" && c.name === serverName
-  ) : clients.filter((c) => c.type === "connected");
-  for (const client of targetClients) {
-    try {
-      const capabilities = await client.client.getServerCapabilities();
-      if (!capabilities?.resources) {
-        continue;
-      }
-      const result = await client.client.request(
-        {
-          method: "resources/read",
-          params: { uri }
-        },
-        ReadResourceResultSchema
-      );
-      if (result.contents && result.contents.length > 0) {
-        const content = result.contents[0];
-        return {
-          uri: content.uri,
-          mimeType: content.mimeType,
-          text: "text" in content ? String(content.text) : void 0,
-          blob: "blob" in content ? String(content.blob) : void 0
-        };
-      } else {
-        emitReminderEvent("mcp:resource_no_content", { resourceUri: uri });
-      }
-    } catch (error) {
-      logMCPError(
-        client.name,
-        `Failed to read resource '${uri}': ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  return null;
-}
-export {
-  addMcpServer,
-  configureMcpPool,
-  ensureConfigScope,
-  getAllCircuitBreakerStats,
-  getClients,
-  getConnectionHealth,
-  getMCPCommands,
-  getMCPTools,
-  getMcpPoolConfig,
-  getMcpServer,
-  getMcprcServerStatus,
-  getPoolStats,
-  getServerCircuitBreaker,
-  getServerHealth,
-  listMCPResources,
-  listMCPServers,
-  parseEnvVars,
-  readMCPResource,
-  refreshMCPConnections,
-  removeMcpServer,
-  runCommand,
-  runHealthCheck,
-  shutdownMCPClients,
-  startHealthCheck,
-  stopHealthCheck
-};
-//# sourceMappingURL=mcpClient.js.map