@elizaos/plugin-mcp 1.3.3 → 1.3.5

package/dist/index.js

@@ -804,7 +804,9 @@ function buildMcpProviderData(servers) {
     }
   }
   return {
-    values: { mcp: mcpData },
+    values: { mcp: mcpData, mcpText: `# MCP Configuration
+
+${textContent}` },
     data: { mcp: mcpData },
     text: `# MCP Configuration
 
@@ -927,6 +929,7 @@ async function handleToolResponse(runtime2, message, serverName, toolName, toolA
       attachments: hasAttachments && attachments.length > 0 ? attachments : undefined
     });
   }
+  return replyMemory;
 }
 async function sendInitialResponse(callback) {
   if (callback) {
@@ -1496,15 +1499,16 @@ var callToolAction = {
 ${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);
-      await handleToolResponse(runtime2, message, serverName, toolName, toolSelectionArgument.toolArguments, toolOutput, hasAttachments, attachments, composedState, mcpProvider, callback);
+      const replyMemory = await handleToolResponse(runtime2, message, serverName, toolName, toolSelectionArgument.toolArguments, toolOutput, hasAttachments, attachments, composedState, mcpProvider, callback);
       return {
-        text: `Successfully called tool: ${serverName}/${toolName}`,
+        text: `Successfully called tool: ${serverName}/${toolName}. Reasoned response: ${replyMemory.content.text}`,
         values: {
           success: true,
           toolExecuted: true,
           serverName,
           toolName,
-          hasAttachments
+          hasAttachments,
+          output: toolOutput
         },
         data: {
           actionName: "CALL_MCP_TOOL",
@@ -1785,7 +1789,7 @@ class McpService extends Service {
   connections = new Map;
   connectionStates = new Map;
   mcpProvider = {
-    values: { mcp: {} },
+    values: { mcp: {}, mcpText: "" },
     data: { mcp: {} },
     text: ""
   };
@@ -1832,18 +1836,38 @@ class McpService extends Service {
       logger7.info(`[McpService] Getting MCP settings... hasSettings=${!!mcpSettings} hasServers=${!!mcpSettings?.servers} serverCount=${serverCount} servers=${JSON.stringify(serverNames)}`);
       if (!mcpSettings || !mcpSettings.servers) {
         logger7.info("[McpService] No MCP servers configured.");
+        this.mcpProvider = buildMcpProviderData([]);
+        return;
+      }
+      if (Object.keys(mcpSettings.servers).length === 0) {
+        logger7.info("[McpService] MCP settings exist but no servers configured.");
+        this.mcpProvider = buildMcpProviderData([]);
         return;
       }
-      logger7.info(`[McpService] Connecting to MCP servers: ${JSON.stringify(Object.keys(mcpSettings.servers))}`);
+      logger7.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 serverStatus = servers.map((s) => `${s.name}:${s.status}:${s.tools?.length || 0}tools`).join(", ");
-      logger7.info(`[McpService] Connected servers: ${serverStatus}`);
+      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(", ");
+        logger7.info(`[McpService] ✓ Successfully connected ${connectedServers.length}/${servers.length} servers in ${connectionDuration}ms: ${toolCounts}`);
+      }
+      if (failedServers.length > 0) {
+        const failedDetails = failedServers.map((s) => `${s.name}(${s.error || "unknown error"})`).join(", ");
+        logger7.warn(`[McpService] ⚠️  Failed to connect to ${failedServers.length}/${servers.length} servers: ${failedDetails}`);
+      }
+      if (connectedServers.length === 0 && servers.length > 0) {
+        logger7.error(`[McpService] ❌ ALL MCP servers failed to connect! MCP tools will NOT be available.`);
+      }
       this.mcpProvider = buildMcpProviderData(servers);
       const mcpDataKeys = Object.keys(this.mcpProvider.data?.mcp || {});
-      logger7.info(`[McpService] MCP provider data built: hasData=${!!this.mcpProvider.data?.mcp} serverCount=${mcpDataKeys.length}`);
+      logger7.info(`[McpService] MCP provider data built: ${mcpDataKeys.length} server(s) available`);
     } catch (error) {
-      logger7.error({ error: error instanceof Error ? error.message : String(error) }, "Failed to initialize MCP servers");
+      logger7.error({ error: error instanceof Error ? error.message : String(error) }, "❌ Failed to initialize MCP servers - MCP tools will NOT be available");
+      this.mcpProvider = buildMcpProviderData([]);
     }
   }
   getMcpSettings() {
@@ -1879,24 +1903,27 @@ class McpService extends Service {
         logger7.info(`Deleted MCP server: ${name}`);
       }
     }
-    for (const [name, config] of Object.entries(serverConfigs)) {
+    const connectionPromises = Object.entries(serverConfigs).map(async ([name, config]) => {
       const currentConnection = this.connections.get(name);
       if (!currentConnection) {
         try {
           await this.initializeConnection(name, config);
+          logger7.info(`✓ Connected to MCP server: ${name}`);
         } catch (error) {
-          logger7.error({ error: error instanceof Error ? error.message : String(error), serverName: name }, `Failed to connect to new MCP server ${name}`);
+          logger7.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);
-          logger7.info(`Reconnected MCP server with updated config: ${name}`);
+          logger7.info(`✓ Reconnected MCP server with updated config: ${name}`);
         } catch (error) {
-          logger7.error({ error: error instanceof Error ? error.message : String(error), serverName: name }, `Failed to reconnect MCP server ${name}`);
+          logger7.error({ error: error instanceof Error ? error.message : String(error), serverName: name }, `✗ Failed to reconnect MCP server ${name}`);
         }
       }
-    }
+    });
+    await Promise.allSettled(connectionPromises);
+    logger7.info(`[McpService] All server connection attempts completed`);
   }
   async initializeConnection(name, config) {
     await this.deleteConnection(name);
@@ -1952,16 +1979,25 @@ class McpService extends Service {
     const config = JSON.parse(connection.server.config);
     const isHttpTransport = config.type !== "stdio";
     connection.transport.onerror = async (error) => {
-      logger7.error({ error, serverName: name }, `Transport error for "${name}"`);
-      connection.server.status = "disconnected";
-      this.appendErrorMessage(connection, error.message);
+      const errorMessage = error?.message || String(error);
+      const isExpectedTimeout = isHttpTransport && (errorMessage === "undefined" || errorMessage === "" || errorMessage.includes("SSE error") || errorMessage.includes("timeout"));
+      if (isExpectedTimeout) {
+        logger7.debug({ serverName: name }, `SSE connection timeout for "${name}" (expected, will reconnect)`);
+      } else {
+        logger7.error({ error, serverName: name }, `Transport error for "${name}"`);
+        connection.server.status = "disconnected";
+        this.appendErrorMessage(connection, error.message);
+      }
       if (!isHttpTransport) {
         this.handleDisconnection(name, error);
       }
     };
     connection.transport.onclose = async () => {
-      connection.server.status = "disconnected";
-      if (!isHttpTransport) {
+      if (isHttpTransport) {
+        logger7.debug({ serverName: name }, `SSE connection closed for "${name}" (stateless, will reconnect on demand)`);
+      } else {
+        logger7.warn({ serverName: name }, `Transport closed for "${name}"`);
+        connection.server.status = "disconnected";
         this.handleDisconnection(name, new Error("Transport closed"));
       }
     };
@@ -2261,4 +2297,4 @@ export {
   BACKOFF_MULTIPLIER
 };
 
-//# debugId=DE4C034ED64F169064756E2164756E21
+//# debugId=7FE3B98268562B6664756E2164756E21