@elizaos/plugin-mcp 1.7.0 → 1.7.1

package/dist/cjs/index.cjs

@@ -711,6 +711,33 @@ async function handleMcpError(state, mcpProvider, error, runtime2, message, type
   };
 }
 
+// src/utils/handler.ts
+async function handleNoToolAvailable(callback, toolSelection) {
+  const responseText = "I don't have a specific tool that can help with that request. Let me try to assist you directly instead.";
+  const thoughtText = "No appropriate MCP tool available for this request. Falling back to direct assistance.";
+  if (callback && toolSelection?.noToolAvailable) {
+    await callback({
+      text: responseText,
+      thought: thoughtText,
+      actions: ["REPLY"]
+    });
+  }
+  return {
+    text: responseText,
+    values: {
+      success: true,
+      noToolAvailable: true,
+      fallbackToDirectAssistance: true
+    },
+    data: {
+      actionName: "CALL_MCP_TOOL",
+      noToolAvailable: true,
+      reason: toolSelection?.reasoning || "No appropriate tool available"
+    },
+    success: true
+  };
+}
+
 // src/utils/processing.ts
 var import_core2 = require("@elizaos/core");
 var import_core3 = require("@elizaos/core");
@@ -775,82 +802,54 @@ Your response (written as if directly to the user):
 `;
 
 // src/utils/mcp.ts
+var NO_DESC = "No description";
 async function createMcpMemory(runtime2, message, type, serverName, content, metadata) {
   const memory = await runtime2.addEmbeddingToMemory({
     entityId: message.entityId,
     agentId: runtime2.agentId,
     roomId: message.roomId,
     content: {
-      text: `Used the "${type}" from "${serverName}" server. 
-        Content: ${content}`,
-      metadata: {
-        ...metadata,
-        serverName
-      }
+      text: `Used "${type}" from "${serverName}". Content: ${content}`,
+      metadata: { ...metadata, serverName }
     }
   });
   await runtime2.createMemory(memory, type === "resource" ? "resources" : "tools", true);
 }
 function buildMcpProviderData(servers) {
-  const mcpData = {};
-  let textContent = "";
   if (servers.length === 0) {
-    return {
-      values: { mcp: {} },
-      data: { mcp: {} },
-      text: "No MCP servers are currently connected."
-    };
+    return { values: { mcp: {} }, data: { mcp: {} }, text: "No MCP servers connected." };
   }
+  const mcpData = {};
+  const lines = [`# MCP Configuration
+`];
   for (const server of servers) {
-    mcpData[server.name] = {
-      status: server.status,
-      tools: {},
-      resources: {}
-    };
-    textContent += `## Server: ${server.name} (${server.status})
-
-`;
-    if (server.tools && server.tools.length > 0) {
-      textContent += `### Tools:
-
-`;
-      for (const tool of server.tools) {
-        mcpData[server.name].tools[tool.name] = {
-          description: tool.description || "No description available",
-          inputSchema: tool.inputSchema || {}
-        };
-        textContent += `- **${tool.name}**: ${tool.description || "No description available"}
-`;
-      }
-      textContent += `
-`;
-    }
-    if (server.resources && server.resources.length > 0) {
-      textContent += `### Resources:
-
-`;
-      for (const resource of server.resources) {
-        mcpData[server.name].resources[resource.uri] = {
-          name: resource.name,
-          description: resource.description || "No description available",
-          mimeType: resource.mimeType
-        };
-        textContent += `- **${resource.name}** (${resource.uri}): ${resource.description || "No description available"}
-`;
-      }
-      textContent += `
-`;
-    }
-  }
-  return {
-    values: { mcp: mcpData, mcpText: `# MCP Configuration
-
-${textContent}` },
-    data: { mcp: mcpData },
-    text: `# MCP Configuration
-
-${textContent}`
-  };
+    const tools = {};
+    const resources = {};
+    lines.push(`## ${server.name} (${server.status})
+`);
+    if (server.tools?.length) {
+      lines.push(`### Tools
+`);
+      for (const t of server.tools) {
+        tools[t.name] = { description: t.description || NO_DESC, inputSchema: t.inputSchema || {} };
+        lines.push(`- **${t.name}**: ${t.description || NO_DESC}`);
+      }
+      lines.push("");
+    }
+    if (server.resources?.length) {
+      lines.push(`### Resources
+`);
+      for (const r of server.resources) {
+        resources[r.uri] = { name: r.name, description: r.description || NO_DESC, mimeType: r.mimeType };
+        lines.push(`- **${r.name}** (${r.uri}): ${r.description || NO_DESC}`);
+      }
+      lines.push("");
+    }
+    mcpData[server.name] = { status: server.status, tools, resources };
+  }
+  const text = lines.join(`
+`);
+  return { values: { mcp: mcpData, mcpText: text }, data: { mcp: mcpData }, text };
 }
 
 // src/utils/processing.ts
@@ -1445,33 +1444,6 @@ function createFeedbackPrompt2(originalResponse, errorMessage, itemType, itemsDe
   User request: ${userMessage}`;
 }
 
-// src/utils/handler.ts
-async function handleNoToolAvailable(callback, toolSelection) {
-  const responseText = "I don't have a specific tool that can help with that request. Let me try to assist you directly instead.";
-  const thoughtText = "No appropriate MCP tool available for this request. Falling back to direct assistance.";
-  if (callback && toolSelection?.noToolAvailable) {
-    await callback({
-      text: responseText,
-      thought: thoughtText,
-      actions: ["REPLY"]
-    });
-  }
-  return {
-    text: responseText,
-    values: {
-      success: true,
-      noToolAvailable: true,
-      fallbackToDirectAssistance: true
-    },
-    data: {
-      actionName: "CALL_MCP_TOOL",
-      noToolAvailable: true,
-      reason: toolSelection?.reasoning || "No appropriate tool available"
-    },
-    success: true
-  };
-}
-
 // src/actions/callToolAction.ts
 var callToolAction = {
   name: "CALL_MCP_TOOL",
@@ -1533,7 +1505,7 @@ ${JSON.stringify(toolSelectionArgument, null, 2)}`);
       const result = await mcpService.callTool(serverName, toolName, toolSelectionArgument.toolArguments);
       const { toolOutput, hasAttachments, attachments } = processToolResult(result, serverName, toolName, runtime2, message.entityId);
       const replyMemory = await handleToolResponse(runtime2, message, serverName, toolName, toolSelectionArgument.toolArguments, toolOutput, hasAttachments, attachments, composedState, mcpProvider, callback);
-      return {
+      const actionResult = {
         text: `Successfully called tool: ${serverName}/${toolName}. Reasoned response: ${replyMemory.content.text}`,
         values: {
           success: true,
@@ -1554,6 +1526,15 @@ ${JSON.stringify(toolSelectionArgument, null, 2)}`);
         },
         success: true
       };
+      import_core6.logger.info({
+        serverName,
+        toolName,
+        hasOutput: !!toolOutput,
+        outputLength: toolOutput?.length || 0,
+        hasAttachments,
+        reasoning: toolSelectionName.reasoning
+      }, `[CALL_MCP_TOOL] Action result`);
+      return actionResult;
     } catch (error) {
       return await handleMcpError(composedState, mcpProvider, error, runtime2, message, "tool", callback);
     }
@@ -1791,19 +1772,20 @@ var readResourceAction = {
 };
 
 // src/provider.ts
+var createEmptyProvider = () => ({
+  values: { mcp: {} },
+  data: { mcp: {} },
+  text: "No MCP servers available."
+});
 var provider = {
   name: "MCP",
-  description: "Information about connected MCP servers, tools, and resources",
+  description: "Connected MCP servers, tools, and resources",
   get: async (runtime2, _message, _state) => {
-    const mcpService = runtime2.getService(MCP_SERVICE_NAME);
-    if (!mcpService) {
-      return {
-        values: { mcp: {} },
-        data: { mcp: {} },
-        text: "No MCP servers are available."
-      };
-    }
-    return mcpService.getProviderData();
+    const svc = runtime2.getService(MCP_SERVICE_NAME);
+    if (!svc)
+      return createEmptyProvider();
+    await svc.waitForInitialization();
+    return svc.getProviderData();
   }
 };
 
@@ -1812,6 +1794,9 @@ var import_core8 = require("@elizaos/core");
 var import_client = require("@modelcontextprotocol/sdk/client/index.js");
 var import_sse = require("@modelcontextprotocol/sdk/client/sse.js");
 var import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
+var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+var errMsg = (e) => e instanceof Error ? e.message : String(e);
+
 class McpService extends import_core8.Service {
   static serviceType = MCP_SERVICE_NAME;
   capabilityDescription = "Enables the agent to interact with MCP (Model Context Protocol) servers";
@@ -1828,7 +1813,6 @@ class McpService extends import_core8.Service {
   initializationPromise = null;
   constructor(runtime2) {
     super(runtime2);
-    import_core8.logger.info("[McpService] Constructor called, starting initialization...");
     this.initializationPromise = this.initializeMcpServers();
   }
   static async start(runtime2) {
@@ -1844,116 +1828,70 @@ class McpService extends import_core8.Service {
     }
   }
   async stop() {
-    for (const [name] of this.connections) {
+    for (const name of this.connections.keys()) {
       await this.deleteConnection(name);
     }
-    this.connections.clear();
-    for (const state of this.connectionStates.values()) {
+    for (const [name, state] of this.connectionStates.entries()) {
       if (state.pingInterval)
         clearInterval(state.pingInterval);
       if (state.reconnectTimeout)
         clearTimeout(state.reconnectTimeout);
+      this.connectionStates.delete(name);
     }
-    this.connectionStates.clear();
   }
   async initializeMcpServers() {
-    import_core8.logger.info("[McpService] Starting MCP server initialization...");
     try {
       const mcpSettings = this.getMcpSettings();
-      const serverCount = mcpSettings?.servers ? Object.keys(mcpSettings.servers).length : 0;
-      const serverNames = mcpSettings?.servers ? Object.keys(mcpSettings.servers) : [];
-      import_core8.logger.info(`[McpService] Getting MCP settings... hasSettings=${!!mcpSettings} hasServers=${!!mcpSettings?.servers} serverCount=${serverCount} servers=${JSON.stringify(serverNames)}`);
-      if (!mcpSettings || !mcpSettings.servers) {
-        import_core8.logger.info("[McpService] No MCP servers configured.");
-        this.mcpProvider = buildMcpProviderData([]);
-        return;
-      }
-      if (Object.keys(mcpSettings.servers).length === 0) {
-        import_core8.logger.info("[McpService] MCP settings exist but no servers configured.");
+      if (!mcpSettings?.servers || Object.keys(mcpSettings.servers).length === 0) {
         this.mcpProvider = buildMcpProviderData([]);
         return;
       }
-      import_core8.logger.info(`[McpService] Connecting to ${Object.keys(mcpSettings.servers).length} MCP servers: ${JSON.stringify(Object.keys(mcpSettings.servers))}`);
       const connectionStartTime = Date.now();
       await this.updateServerConnections(mcpSettings.servers);
       const connectionDuration = Date.now() - connectionStartTime;
       const servers = this.getServers();
-      const connectedServers = servers.filter((s) => s.status === "connected");
-      const failedServers = servers.filter((s) => s.status !== "connected");
-      if (connectedServers.length > 0) {
-        const toolCounts = connectedServers.map((s) => `${s.name}:${s.tools?.length || 0}tools`).join(", ");
-        import_core8.logger.info(`[McpService] ✓ Successfully connected ${connectedServers.length}/${servers.length} servers in ${connectionDuration}ms: ${toolCounts}`);
+      const connected = servers.filter((s) => s.status === "connected");
+      const failed = servers.filter((s) => s.status !== "connected");
+      if (connected.length > 0) {
+        import_core8.logger.info(`[MCP] Connected ${connected.length}/${servers.length} in ${connectionDuration}ms (${connected.map((s) => `${s.name}:${s.tools?.length || 0}`).join(", ")})`);
       }
-      if (failedServers.length > 0) {
-        const failedDetails = failedServers.map((s) => `${s.name}(${s.error || "unknown error"})`).join(", ");
-        import_core8.logger.warn(`[McpService] ⚠️  Failed to connect to ${failedServers.length}/${servers.length} servers: ${failedDetails}`);
+      if (failed.length > 0) {
+        import_core8.logger.warn(`[MCP] Failed: ${failed.map((s) => s.name).join(", ")}`);
       }
-      if (connectedServers.length === 0 && servers.length > 0) {
-        import_core8.logger.error(`[McpService] ❌ ALL MCP servers failed to connect! MCP tools will NOT be available.`);
+      if (connected.length === 0 && servers.length > 0) {
+        import_core8.logger.error(`[MCP] All servers failed`);
       }
       this.mcpProvider = buildMcpProviderData(servers);
-      const mcpDataKeys = Object.keys(this.mcpProvider.data?.mcp || {});
-      import_core8.logger.info(`[McpService] MCP provider data built: ${mcpDataKeys.length} server(s) available`);
     } catch (error) {
-      import_core8.logger.error({ error: error instanceof Error ? error.message : String(error) }, "❌ Failed to initialize MCP servers - MCP tools will NOT be available");
+      import_core8.logger.error({ error: errMsg(error) }, "[MCP] Initialization failed");
       this.mcpProvider = buildMcpProviderData([]);
     }
   }
   getMcpSettings() {
-    const rawSettings = this.runtime.getSetting("mcp");
-    let settings = rawSettings;
-    import_core8.logger.info(`[McpService] getSetting("mcp") result: type=${typeof rawSettings} isNull=${rawSettings === null} hasServers=${!!settings?.servers}`);
-    if (!settings || !settings.servers) {
-      const characterSettings = this.runtime.character?.settings;
-      if (characterSettings?.mcp) {
-        import_core8.logger.info("[McpService] Found MCP settings in character.settings.mcp (fallback)");
-        settings = characterSettings.mcp;
-      }
-    }
-    if (!settings || !settings.servers) {
-      const runtimeSettings = this.runtime.settings;
-      if (runtimeSettings?.mcp) {
-        import_core8.logger.info("[McpService] Found MCP settings in runtime.settings.mcp (fallback)");
-        settings = runtimeSettings.mcp;
-      }
+    let settings = this.runtime.getSetting("mcp");
+    if (!settings || typeof settings === "object" && !settings.servers) {
+      settings = this.runtime.character?.settings?.mcp;
     }
-    if (settings && typeof settings === "object" && settings.servers) {
-      import_core8.logger.info(`[McpService] MCP settings found with ${Object.keys(settings.servers).length} server(s)`);
-      return settings;
+    if (!settings || typeof settings === "object" && !settings.servers) {
+      settings = this.runtime.settings?.mcp;
     }
-    import_core8.logger.info("[McpService] No valid MCP settings found");
-    return;
+    return settings && typeof settings === "object" && settings.servers ? settings : undefined;
   }
   async updateServerConnections(serverConfigs) {
-    const currentNames = new Set(this.connections.keys());
     const newNames = new Set(Object.keys(serverConfigs));
-    for (const name of currentNames) {
-      if (!newNames.has(name)) {
+    for (const name of this.connections.keys()) {
+      if (!newNames.has(name))
         await this.deleteConnection(name);
-        import_core8.logger.info(`Deleted MCP server: ${name}`);
-      }
     }
-    const connectionPromises = Object.entries(serverConfigs).map(async ([name, config]) => {
-      const currentConnection = this.connections.get(name);
-      if (!currentConnection) {
-        try {
-          await this.initializeConnection(name, config);
-          import_core8.logger.info(`✓ Connected to MCP server: ${name}`);
-        } catch (error) {
-          import_core8.logger.error({ error: error instanceof Error ? error.message : String(error), serverName: name }, `✗ Failed to connect to new MCP server ${name}`);
-        }
-      } else if (JSON.stringify(config) !== currentConnection.server.config) {
-        try {
-          await this.deleteConnection(name);
-          await this.initializeConnection(name, config);
-          import_core8.logger.info(`✓ Reconnected MCP server with updated config: ${name}`);
-        } catch (error) {
-          import_core8.logger.error({ error: error instanceof Error ? error.message : String(error), serverName: name }, `✗ Failed to reconnect MCP server ${name}`);
-        }
+    await Promise.allSettled(Object.entries(serverConfigs).map(async ([name, config]) => {
+      const current = this.connections.get(name);
+      if (!current) {
+        await this.initializeConnection(name, config).catch((e) => import_core8.logger.error({ error: errMsg(e), serverName: name }, `[MCP] Failed: ${name}`));
+      } else if (JSON.stringify(config) !== current.server.config) {
+        await this.deleteConnection(name);
+        await this.initializeConnection(name, config).catch((e) => import_core8.logger.error({ error: errMsg(e), serverName: name }, `[MCP] Failed: ${name}`));
       }
-    });
-    await Promise.allSettled(connectionPromises);
-    import_core8.logger.info(`[McpService] All server connection attempts completed`);
+    }));
   }
   async initializeConnection(name, config) {
     await this.deleteConnection(name);
@@ -1967,19 +1905,19 @@ class McpService extends import_core8.Service {
       const client = new import_client.Client({ name: "ElizaOS", version: "1.0.0" }, { capabilities: {} });
       const transport = config.type === "stdio" ? await this.buildStdioClientTransport(name, config) : await this.buildHttpClientTransport(name, config);
       const connection = {
-        server: {
-          name,
-          config: JSON.stringify(config),
-          status: "connecting"
-        },
+        server: { name, config: JSON.stringify(config), status: "connecting" },
         client,
         transport
       };
       this.connections.set(name, connection);
       this.setupTransportHandlers(name, connection, state);
-      await client.connect(transport);
+      const connectPromise = client.connect(transport);
+      connectPromise.catch(() => {});
+      await Promise.race([
+        connectPromise,
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout connecting to ${name}`)), 60000))
+      ]);
       const capabilities = client.getServerCapabilities();
-      import_core8.logger.debug(`[${name}] Server capabilities:`, JSON.stringify(capabilities || {}));
       const tools = await this.fetchToolsList(name);
       const resources = capabilities?.resources ? await this.fetchResourcesList(name) : [];
       const resourceTemplates = capabilities?.resources ? await this.fetchResourceTemplatesList(name) : [];
@@ -1997,7 +1935,6 @@ class McpService extends import_core8.Service {
       state.reconnectAttempts = 0;
       state.consecutivePingFailures = 0;
       this.startPingMonitoring(name);
-      import_core8.logger.info(`Successfully connected to MCP server: ${name}`);
     } catch (error) {
       state.status = "disconnected";
       state.lastError = error instanceof Error ? error : new Error(String(error));
@@ -2007,26 +1944,21 @@ class McpService extends import_core8.Service {
   }
   setupTransportHandlers(name, connection, state) {
     const config = JSON.parse(connection.server.config);
-    const isHttpTransport = config.type !== "stdio";
+    const isHttp = config.type !== "stdio";
     connection.transport.onerror = async (error) => {
-      const errorMessage = error?.message || String(error);
-      const isExpectedTimeout = isHttpTransport && (errorMessage === "undefined" || errorMessage === "" || errorMessage.includes("SSE error") || errorMessage.includes("timeout"));
-      if (isExpectedTimeout) {
-        import_core8.logger.debug({ serverName: name }, `SSE connection timeout for "${name}" (expected, will reconnect)`);
-      } else {
-        import_core8.logger.error({ error, serverName: name }, `Transport error for "${name}"`);
+      const msg = error?.message || String(error);
+      const isExpectedTimeout = isHttp && (!msg || msg === "undefined" || msg.includes("SSE") || msg.includes("timeout"));
+      if (!isExpectedTimeout) {
+        import_core8.logger.error({ error, serverName: name }, `Transport error: ${name}`);
         connection.server.status = "disconnected";
-        this.appendErrorMessage(connection, error.message);
+        this.appendErrorMessage(connection, msg);
       }
-      if (!isHttpTransport) {
+      if (!isHttp)
         this.handleDisconnection(name, error);
-      }
     };
     connection.transport.onclose = async () => {
-      if (isHttpTransport) {
-        import_core8.logger.debug({ serverName: name }, `SSE connection closed for "${name}" (stateless, will reconnect on demand)`);
-      } else {
-        import_core8.logger.warn({ serverName: name }, `Transport closed for "${name}"`);
+      if (!isHttp) {
+        import_core8.logger.warn({ serverName: name }, `Transport closed: ${name}`);
         connection.server.status = "disconnected";
         this.handleDisconnection(name, new Error("Transport closed"));
       }
@@ -2037,11 +1969,8 @@ class McpService extends import_core8.Service {
     if (!connection)
       return;
     const config = JSON.parse(connection.server.config);
-    const isHttpTransport = config.type !== "stdio";
-    if (isHttpTransport) {
-      import_core8.logger.debug(`[McpService] Skipping ping monitoring for HTTP server: ${name}`);
+    if (config.type !== "stdio")
       return;
-    }
     const state = this.connectionStates.get(name);
     if (!state || !this.pingConfig.enabled)
       return;
@@ -2049,7 +1978,7 @@ class McpService extends import_core8.Service {
       clearInterval(state.pingInterval);
     state.pingInterval = setInterval(() => {
       this.sendPing(name).catch((err) => {
-        import_core8.logger.warn({ error: err instanceof Error ? err.message : String(err), serverName: name }, `Ping failed for ${name}`);
+        import_core8.logger.warn({ error: errMsg(err), serverName: name }, `Ping failed: ${name}`);
         this.handlePingFailure(name, err);
       });
     }, this.pingConfig.intervalMs);
@@ -2057,7 +1986,7 @@ class McpService extends import_core8.Service {
   async sendPing(name) {
     const connection = this.connections.get(name);
     if (!connection)
-      throw new Error(`No connection for ping: ${name}`);
+      throw new Error(`No connection: ${name}`);
     await Promise.race([
       connection.client.listTools(),
       new Promise((_, reject) => setTimeout(() => reject(new Error("Ping timeout")), this.pingConfig.timeoutMs))
@@ -2099,7 +2028,7 @@ class McpService extends import_core8.Service {
         try {
           await this.initializeConnection(name, JSON.parse(config));
         } catch (err) {
-          import_core8.logger.error({ error: err instanceof Error ? err.message : String(err), serverName: name }, `Reconnect attempt failed for ${name}`);
+          import_core8.logger.error({ error: errMsg(err), serverName: name }, `Reconnect attempt failed for ${name}`);
           this.handleDisconnection(name, err);
         }
       }
@@ -2112,7 +2041,7 @@ class McpService extends import_core8.Service {
         await connection.transport.close();
         await connection.client.close();
       } catch (error) {
-        import_core8.logger.error({ error: error instanceof Error ? error.message : String(error), serverName: name }, `Failed to close transport for ${name}`);
+        import_core8.logger.error({ error: errMsg(error), serverName: name }, `Failed to close transport for ${name}`);
       }
       this.connections.delete(name);
     }
@@ -2125,9 +2054,6 @@ class McpService extends import_core8.Service {
       this.connectionStates.delete(name);
     }
   }
-  getServerConnection(serverName) {
-    return this.connections.get(serverName);
-  }
   async buildStdioClientTransport(name, config) {
     if (!config.command) {
       throw new Error(`Missing command for stdio MCP server ${name}`);
@@ -2144,74 +2070,61 @@ class McpService extends import_core8.Service {
     });
   }
   async buildHttpClientTransport(name, config) {
-    if (!config.url) {
-      throw new Error(`Missing URL for HTTP MCP server ${name}`);
-    }
+    if (!config.url)
+      throw new Error(`Missing URL for MCP server ${name}`);
+    const url = new URL(config.url);
+    const opts = config.headers ? { requestInit: { headers: config.headers } } : undefined;
     if (config.type === "sse") {
-      import_core8.logger.warn(`Server "${name}": "sse" transport type is deprecated. Use "streamable-http" or "http" instead for the modern Streamable HTTP transport.`);
+      import_core8.logger.warn(`[MCP] "${name}": SSE requires Redis. Use "streamable-http" instead.`);
+      return new import_sse.SSEClientTransport(url, opts);
     }
-    return new import_sse.SSEClientTransport(new URL(config.url));
+    return new import_streamableHttp.StreamableHTTPClientTransport(url, opts);
   }
   appendErrorMessage(connection, error) {
-    const newError = connection.server.error ? `${connection.server.error}
+    connection.server.error = connection.server.error ? `${connection.server.error}
 ${error}` : error;
-    connection.server.error = newError;
   }
   async fetchToolsList(serverName) {
+    const connection = this.connections.get(serverName);
+    if (!connection)
+      return [];
     try {
-      const connection = this.getServerConnection(serverName);
-      if (!connection) {
-        return [];
-      }
       const response = await connection.client.listTools();
-      const tools = (response?.tools || []).map((tool) => {
-        let processedTool = { ...tool };
-        if (tool.inputSchema) {
-          try {
-            if (!this.compatibilityInitialized) {
-              this.initializeToolCompatibility();
-            }
-            processedTool.inputSchema = this.applyToolCompatibility(tool.inputSchema);
-            import_core8.logger.debug(`Applied tool compatibility for: ${tool.name} on server: ${serverName}`);
-          } catch (error) {
-            import_core8.logger.warn({ error, toolName: tool.name, serverName }, `Tool compatibility failed for ${tool.name} on ${serverName}`);
-          }
+      return (response?.tools || []).map((tool) => {
+        if (!tool.inputSchema)
+          return tool;
+        if (!this.compatibilityInitialized)
+          this.initializeToolCompatibility();
+        try {
+          return { ...tool, inputSchema: this.applyToolCompatibility(tool.inputSchema) };
+        } catch {
+          return tool;
         }
-        return processedTool;
       });
-      import_core8.logger.info(`Fetched ${tools.length} tools for ${serverName}`);
-      for (const tool of tools) {
-        import_core8.logger.info(`[${serverName}] ${tool.name}: ${tool.description}`);
-      }
-      return tools;
     } catch (error) {
-      import_core8.logger.error({ error: error instanceof Error ? error.message : String(error), serverName }, `Failed to fetch tools for ${serverName}`);
+      import_core8.logger.error({ error: errMsg(error), serverName }, `Failed to fetch tools: ${serverName}`);
       return [];
     }
   }
-  async fetchResourcesList(serverName) {
+  async fetchResourcesList(name) {
+    const conn = this.connections.get(name);
+    if (!conn)
+      return [];
     try {
-      const connection = this.getServerConnection(serverName);
-      if (!connection) {
-        return [];
-      }
-      const response = await connection.client.listResources();
-      return response?.resources || [];
+      return (await conn.client.listResources())?.resources || [];
     } catch (error) {
-      import_core8.logger.warn({ error: error instanceof Error ? error.message : String(error), serverName }, `No resources found for ${serverName}`);
+      import_core8.logger.debug({ error: errMsg(error), serverName: name }, `No resources for ${name}`);
       return [];
     }
   }
-  async fetchResourceTemplatesList(serverName) {
+  async fetchResourceTemplatesList(name) {
+    const conn = this.connections.get(name);
+    if (!conn)
+      return [];
     try {
-      const connection = this.getServerConnection(serverName);
-      if (!connection) {
-        return [];
-      }
-      const response = await connection.client.listResourceTemplates();
-      return response?.resourceTemplates || [];
+      return (await conn.client.listResourceTemplates())?.resourceTemplates || [];
     } catch (error) {
-      import_core8.logger.warn({ error: error instanceof Error ? error.message : String(error), serverName }, `No resource templates found for ${serverName}`);
+      import_core8.logger.debug({ error: errMsg(error), serverName: name }, `No resource templates for ${name}`);
       return [];
     }
   }
@@ -2221,76 +2134,53 @@ ${error}` : error;
   getProviderData() {
     return this.mcpProvider;
   }
-  async callTool(serverName, toolName, toolArguments) {
-    const connection = this.connections.get(serverName);
-    if (!connection) {
-      throw new Error(`No connection found for server: ${serverName}`);
-    }
-    if (connection.server.disabled) {
-      throw new Error(`Server "${serverName}" is disabled`);
-    }
-    let timeout = DEFAULT_MCP_TIMEOUT_SECONDS;
-    try {
-      const config = JSON.parse(connection.server.config);
-      timeout = config.timeoutInMillis || DEFAULT_MCP_TIMEOUT_SECONDS;
-    } catch (error) {
-      import_core8.logger.error({ error: error instanceof Error ? error.message : String(error), serverName }, `Failed to parse timeout configuration for server ${serverName}`);
-    }
-    const result = await connection.client.callTool({ name: toolName, arguments: toolArguments }, undefined, { timeout });
-    if (!result.content) {
-      throw new Error("Invalid tool result: missing content array");
-    }
+  async callTool(serverName, toolName, args) {
+    const conn = this.connections.get(serverName);
+    if (!conn)
+      throw new Error(`No connection: ${serverName}`);
+    if (conn.server.disabled)
+      throw new Error(`Server disabled: ${serverName}`);
+    const config = JSON.parse(conn.server.config);
+    const timeout = (config.type === "stdio" ? config.timeoutInMillis : config.timeout) ?? DEFAULT_MCP_TIMEOUT_SECONDS;
+    const result = await conn.client.callTool({ name: toolName, arguments: args }, undefined, {
+      timeout
+    });
+    if (!result.content)
+      throw new Error("Invalid tool result: missing content");
     return result;
   }
   async readResource(serverName, uri) {
-    const connection = this.connections.get(serverName);
-    if (!connection) {
-      throw new Error(`No connection found for server: ${serverName}`);
-    }
-    if (connection.server.disabled) {
-      throw new Error(`Server "${serverName}" is disabled`);
-    }
-    return await connection.client.readResource({ uri });
+    const conn = this.connections.get(serverName);
+    if (!conn)
+      throw new Error(`No connection: ${serverName}`);
+    if (conn.server.disabled)
+      throw new Error(`Server disabled: ${serverName}`);
+    return conn.client.readResource({ uri });
   }
   async restartConnection(serverName) {
-    const connection = this.connections.get(serverName);
-    const config = connection?.server.config;
-    if (config) {
-      import_core8.logger.info(`Restarting ${serverName} MCP server...`);
-      connection.server.status = "connecting";
-      connection.server.error = "";
-      try {
-        await this.deleteConnection(serverName);
-        await this.initializeConnection(serverName, JSON.parse(config));
-        import_core8.logger.info(`${serverName} MCP server connected`);
-      } catch (error) {
-        import_core8.logger.error({ error: error instanceof Error ? error.message : String(error), serverName }, `Failed to restart connection for ${serverName}`);
-        throw new Error(`Failed to connect to ${serverName} MCP server`);
-      }
-    }
+    const conn = this.connections.get(serverName);
+    if (!conn)
+      throw new Error(`No connection: ${serverName}`);
+    const config = conn.server.config;
+    conn.server.status = "connecting";
+    conn.server.error = "";
+    await this.deleteConnection(serverName);
+    await this.initializeConnection(serverName, JSON.parse(config));
   }
   initializeToolCompatibility() {
     if (this.compatibilityInitialized)
       return;
     this.toolCompatibility = createMcpToolCompatibilitySync(this.runtime);
     this.compatibilityInitialized = true;
-    if (this.toolCompatibility) {
-      import_core8.logger.info(`Tool compatibility enabled`);
-    } else {
-      import_core8.logger.info(`No tool compatibility needed`);
-    }
   }
   applyToolCompatibility(toolSchema) {
-    if (!this.compatibilityInitialized) {
+    if (!this.compatibilityInitialized)
       this.initializeToolCompatibility();
-    }
-    if (!this.toolCompatibility || !toolSchema) {
+    if (!this.toolCompatibility || !toolSchema)
       return toolSchema;
-    }
     try {
       return this.toolCompatibility.transformToolSchema(toolSchema);
-    } catch (error) {
-      import_core8.logger.warn({ error }, `Tool compatibility transformation failed`);
+    } catch {
       return toolSchema;
     }
   }
@@ -2309,4 +2199,4 @@ var mcpPlugin = {
 };
 var src_default = mcpPlugin;
 
-//# debugId=362D3DF72359421664756E2164756E21
+//# debugId=4999FDCEADE0A8A564756E2164756E21