@elizaos/plugin-mcp 1.3.3 → 1.3.5

package/dist/actions/callToolAction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"callToolAction.d.ts","sourceRoot":"","sources":["../../src/actions/callToolAction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EAOZ,MAAM,eAAe,CAAC;AAQvB,eAAO,MAAM,cAAc,EAAE,MAqK5B,CAAC"}
+{"version":3,"file":"callToolAction.d.ts","sourceRoot":"","sources":["../../src/actions/callToolAction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EAOZ,MAAM,eAAe,CAAC;AAQvB,eAAO,MAAM,cAAc,EAAE,MAsK5B,CAAC"}

package/dist/cjs/index.cjs

@@ -843,7 +843,9 @@ function buildMcpProviderData(servers) {
     }
   }
   return {
-    values: { mcp: mcpData },
+    values: { mcp: mcpData, mcpText: `# MCP Configuration
+
+${textContent}` },
     data: { mcp: mcpData },
     text: `# MCP Configuration
 
@@ -966,6 +968,7 @@ async function handleToolResponse(runtime2, message, serverName, toolName, toolA
       attachments: hasAttachments && attachments.length > 0 ? attachments : undefined
     });
   }
+  return replyMemory;
 }
 async function sendInitialResponse(callback) {
   if (callback) {
@@ -1528,15 +1531,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",
@@ -1813,7 +1817,7 @@ class McpService extends import_core8.Service {
   connections = new Map;
   connectionStates = new Map;
   mcpProvider = {
-    values: { mcp: {} },
+    values: { mcp: {}, mcpText: "" },
     data: { mcp: {} },
     text: ""
   };
@@ -1860,18 +1864,38 @@ class McpService extends import_core8.Service {
       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.");
+        this.mcpProvider = buildMcpProviderData([]);
         return;
       }
-      import_core8.logger.info(`[McpService] Connecting to MCP servers: ${JSON.stringify(Object.keys(mcpSettings.servers))}`);
+      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 serverStatus = servers.map((s) => `${s.name}:${s.status}:${s.tools?.length || 0}tools`).join(", ");
-      import_core8.logger.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(", ");
+        import_core8.logger.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(", ");
+        import_core8.logger.warn(`[McpService] ⚠️  Failed to connect to ${failedServers.length}/${servers.length} servers: ${failedDetails}`);
+      }
+      if (connectedServers.length === 0 && servers.length > 0) {
+        import_core8.logger.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 || {});
-      import_core8.logger.info(`[McpService] MCP provider data built: hasData=${!!this.mcpProvider.data?.mcp} serverCount=${mcpDataKeys.length}`);
+      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");
+      import_core8.logger.error({ error: error instanceof Error ? error.message : String(error) }, "❌ Failed to initialize MCP servers - MCP tools will NOT be available");
+      this.mcpProvider = buildMcpProviderData([]);
     }
   }
   getMcpSettings() {
@@ -1907,24 +1931,27 @@ class McpService extends import_core8.Service {
         import_core8.logger.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);
+          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}`);
+          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}`);
+          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}`);
+          import_core8.logger.error({ error: error instanceof Error ? error.message : String(error), serverName: name }, `✗ Failed to reconnect MCP server ${name}`);
         }
       }
-    }
+    });
+    await Promise.allSettled(connectionPromises);
+    import_core8.logger.info(`[McpService] All server connection attempts completed`);
   }
   async initializeConnection(name, config) {
     await this.deleteConnection(name);
@@ -1980,16 +2007,25 @@ class McpService extends import_core8.Service {
     const config = JSON.parse(connection.server.config);
     const isHttpTransport = config.type !== "stdio";
     connection.transport.onerror = async (error) => {
-      import_core8.logger.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) {
+        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}"`);
+        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) {
+        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}"`);
+        connection.server.status = "disconnected";
         this.handleDisconnection(name, new Error("Transport closed"));
       }
     };
@@ -2271,4 +2307,4 @@ var mcpPlugin = {
 };
 var src_default = mcpPlugin;
 
-//# debugId=34EAF1FC6963A4A664756E2164756E21
+//# debugId=06B19883B039D4B264756E2164756E21