@mastra/mcp 0.3.10-alpha.5 → 0.3.10-alpha.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/mcp",
-  "version": "0.3.10-alpha.5",
+  "version": "0.3.10-alpha.6",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -26,7 +26,7 @@
     "date-fns": "^4.1.0",
     "exit-hook": "^4.0.0",
     "uuid": "^11.1.0",
-    "@mastra/core": "^0.8.3-alpha.4"
+    "@mastra/core": "^0.8.3-alpha.5"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^1.1.15",

package/src/client.ts

@@ -9,28 +9,68 @@ import type { StdioServerParameters } from '@modelcontextprotocol/sdk/client/std
 import { DEFAULT_REQUEST_TIMEOUT_MSEC } from '@modelcontextprotocol/sdk/shared/protocol.js';
 import type { Protocol } from '@modelcontextprotocol/sdk/shared/protocol.js';
 import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
-import type { ClientCapabilities } from '@modelcontextprotocol/sdk/types.js';
+import type { ClientCapabilities, LoggingLevel } from '@modelcontextprotocol/sdk/types.js';
 import { CallToolResultSchema, ListResourcesResultSchema } from '@modelcontextprotocol/sdk/types.js';
 
 import { asyncExitHook, gracefulExit } from 'exit-hook';
+import { z } from 'zod';
+
+// Re-export MCP SDK LoggingLevel for convenience
+export type { LoggingLevel } from '@modelcontextprotocol/sdk/types.js';
+
+export interface LogMessage {
+  level: LoggingLevel;
+  message: string;
+  timestamp: Date;
+  serverName: string;
+  details?: Record<string, any>;
+}
+
+export type LogHandler = (logMessage: LogMessage) => void;
 
 // Omit the fields we want to control from the SDK options
 type SSEClientParameters = {
   url: URL;
-  timeout?: number;
 } & SSEClientTransportOptions;
 
-type StdioServerParametersWithTimeout = StdioServerParameters & {
+export type MastraMCPServerDefinition = (StdioServerParameters | SSEClientParameters) & {
+  logger?: LogHandler;
   timeout?: number;
+  capabilities?: ClientCapabilities;
+  enableServerLogs?: boolean;
 };
 
-export type MastraMCPServerDefinition = StdioServerParametersWithTimeout | SSEClientParameters;
+/**
+ * Convert an MCP LoggingLevel to a logger method name that exists in our logger
+ */
+function convertLogLevelToLoggerMethod(level: LoggingLevel): 'debug' | 'info' | 'warn' | 'error' {
+  switch (level) {
+    case 'debug':
+      return 'debug';
+    case 'info':
+    case 'notice':
+      return 'info';
+    case 'warning':
+      return 'warn';
+    case 'error':
+    case 'critical':
+    case 'alert':
+    case 'emergency':
+      return 'error';
+    default:
+      // For any other levels, default to info
+      return 'info';
+  }
+}
 
 export class MastraMCPClient extends MastraBase {
   name: string;
   private transport: Transport;
   private client: Client;
   private readonly timeout: number;
+  private logHandler?: LogHandler;
+  private enableServerLogs?: boolean;
+
   constructor({
     name,
     version = '1.0.0',
@@ -47,17 +87,22 @@ export class MastraMCPClient extends MastraBase {
     super({ name: 'MastraMCPClient' });
     this.name = name;
     this.timeout = timeout;
+    this.logHandler = server.logger;
+    this.enableServerLogs = server.enableServerLogs ?? true;
+
+    // Extract log handler from server config to avoid passing it to transport
+    const { logger, enableServerLogs, ...serverConfig } = server;
 
-    if (`url` in server) {
-      this.transport = new SSEClientTransport(server.url, {
-        requestInit: server.requestInit,
-        eventSourceInit: server.eventSourceInit,
+    if (`url` in serverConfig) {
+      this.transport = new SSEClientTransport(serverConfig.url, {
+        requestInit: serverConfig.requestInit,
+        eventSourceInit: serverConfig.eventSourceInit,
       });
     } else {
       this.transport = new StdioClientTransport({
-        ...server,
+        ...serverConfig,
         // without ...getDefaultEnvironment() commands like npx will fail because there will be no PATH env var
-        env: { ...getDefaultEnvironment(), ...(server.env || {}) },
+        env: { ...getDefaultEnvironment(), ...(serverConfig.env || {}) },
       });
     }
 
@@ -70,6 +115,53 @@ export class MastraMCPClient extends MastraBase {
         capabilities,
       },
     );
+
+    // Set up log message capturing
+    this.setupLogging();
+  }
+
+  /**
+   * Log a message at the specified level
+   * @param level Log level
+   * @param message Log message
+   * @param details Optional additional details
+   */
+  private log(level: LoggingLevel, message: string, details?: Record<string, any>): void {
+    // Convert MCP logging level to our logger method
+    const loggerMethod = convertLogLevelToLoggerMethod(level);
+
+    // Log to internal logger
+    this.logger[loggerMethod](message, details);
+
+    // Send to registered handler if available
+    if (this.logHandler) {
+      this.logHandler({
+        level,
+        message,
+        timestamp: new Date(),
+        serverName: this.name,
+        details,
+      });
+    }
+  }
+
+  private setupLogging(): void {
+    if (this.enableServerLogs) {
+      this.client.setNotificationHandler(
+        z.object({
+          method: z.literal('notifications/message'),
+          params: z
+            .object({
+              level: z.string(),
+            })
+            .passthrough(),
+        }),
+        notification => {
+          const { level, ...params } = notification.params;
+          this.log(level as LoggingLevel, '[MCP SERVER LOG]', params);
+        },
+      );
+    }
   }
 
   private isConnected = false;
@@ -77,12 +169,14 @@ export class MastraMCPClient extends MastraBase {
   async connect() {
     if (this.isConnected) return;
     try {
+      this.log('debug', `Connecting to MCP server`);
       await this.client.connect(this.transport, {
         timeout: this.timeout,
       });
       this.isConnected = true;
       const originalOnClose = this.client.onclose;
       this.client.onclose = () => {
+        this.log('debug', `MCP server connection closed`);
         this.isConnected = false;
         if (typeof originalOnClose === `function`) {
           originalOnClose();
@@ -90,38 +184,43 @@ export class MastraMCPClient extends MastraBase {
       };
       asyncExitHook(
         async () => {
-          this.logger.debug(`Disconnecting ${this.name} MCP server`);
+          this.log('debug', `Disconnecting MCP server during exit`);
           await this.disconnect();
         },
         { wait: 5000 },
       );
 
       process.on('SIGTERM', () => gracefulExit());
+      this.log('info', `Successfully connected to MCP server`);
     } catch (e) {
-      this.logger.error(
-        `Failed connecting to MCPClient with name ${this.name}.\n${e instanceof Error ? e.stack : JSON.stringify(e, null, 2)}`,
-      );
+      this.log('error', `Failed connecting to MCP server`, {
+        error: e instanceof Error ? e.stack : JSON.stringify(e, null, 2),
+      });
       this.isConnected = false;
       throw e;
     }
   }
 
   async disconnect() {
+    this.log('debug', `Disconnecting from MCP server`);
     return await this.client.close();
   }
 
   // TODO: do the type magic to return the right method type. Right now we get infinitely deep infered type errors from Zod without using "any"
 
   async resources(): Promise<ReturnType<Protocol<any, any, any>['request']>> {
+    this.log('debug', `Requesting resources from MCP server`);
     return await this.client.request({ method: 'resources/list' }, ListResourcesResultSchema, {
       timeout: this.timeout,
     });
   }
 
   async tools() {
+    this.log('debug', `Requesting tools from MCP server`);
     const { tools } = await this.client.listTools({ timeout: this.timeout });
     const toolsRes: Record<string, any> = {};
     tools.forEach(tool => {
+      this.log('debug', `Processing tool: ${tool.name}`);
       const s = jsonSchemaToModel(tool.inputSchema);
       const mastraTool = createTool({
         id: `${this.name}_${tool.name}`,
@@ -129,6 +228,7 @@ export class MastraMCPClient extends MastraBase {
         inputSchema: s,
         execute: async ({ context }) => {
           try {
+            this.log('debug', `Executing tool: ${tool.name}`, { toolArgs: context });
             const res = await this.client.callTool(
               {
                 name: tool.name,
@@ -139,11 +239,13 @@ export class MastraMCPClient extends MastraBase {
                 timeout: this.timeout,
               },
             );
-
+            this.log('debug', `Tool executed successfully: ${tool.name}`);
             return res;
           } catch (e) {
-            console.log('Error calling tool', tool.name);
-            console.error(e);
+            this.log('error', `Error calling tool: ${tool.name}`, {
+              error: e instanceof Error ? e.stack : JSON.stringify(e, null, 2),
+              toolArgs: context,
+            });
             throw e;
           }
         },

package/src/configuration.ts

@@ -6,16 +6,18 @@ import type { MastraMCPServerDefinition } from './client';
 
 const mastraMCPConfigurationInstances = new Map<string, InstanceType<typeof MCPConfiguration>>();
 
+export interface MCPConfigurationOptions {
+  id?: string;
+  servers: Record<string, MastraMCPServerDefinition>;
+  timeout?: number; // Optional global timeout
+}
+
 export class MCPConfiguration extends MastraBase {
   private serverConfigs: Record<string, MastraMCPServerDefinition> = {};
   private id: string;
   private defaultTimeout: number;
 
-  constructor(args: {
-    id?: string;
-    servers: Record<string, MastraMCPServerDefinition>;
-    timeout?: number; // Optional global timeout
-  }) {
+  constructor(args: MCPConfigurationOptions) {
     super({ name: 'MCPConfiguration' });
     this.defaultTimeout = args.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
     this.serverConfigs = args.servers;
@@ -100,6 +102,7 @@ To fix this you have three different options:
 
     this.logger.debug(`Connecting to ${name} MCP server`);
 
+    // Create client with server configuration including log handler
     const mcpClient = new MastraMCPClient({
       name,
       server: config,
@@ -111,7 +114,9 @@ To fix this you have three different options:
       await mcpClient.connect();
     } catch (e) {
       this.mcpClientsById.delete(name);
-      this.logger.error(`MCPConfiguration errored connecting to MCP server ${name}`);
+      this.logger.error(`MCPConfiguration errored connecting to MCP server ${name}`, {
+        error: e instanceof Error ? e.message : String(e),
+      });
       throw e;
     }
 

package/src/server-logging.test.ts

@@ -0,0 +1,189 @@
+import { spawn } from 'child_process';
+import path from 'path';
+import { describe, it, expect, vi, beforeEach, afterEach, beforeAll, afterAll } from 'vitest';
+import type { LogMessage, LoggingLevel } from './client';
+import { MCPConfiguration } from './configuration';
+
+// Increase test timeout for server operations
+vi.setConfig({ testTimeout: 80000, hookTimeout: 80000 });
+
+describe('MCP Server Logging', () => {
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+  let weatherProcess: ReturnType<typeof spawn>;
+
+  beforeAll(async () => {
+    // Start the weather SSE server
+    weatherProcess = spawn('npx', ['-y', 'tsx', path.join(__dirname, '__fixtures__/weather.ts')], {
+      env: { ...process.env, PORT: '60809' },
+    });
+
+    // Wait for SSE server to be ready
+    let resolved = false;
+    await new Promise<void>((resolve, reject) => {
+      weatherProcess.on(`exit`, () => {
+        if (!resolved) reject();
+      });
+      if (weatherProcess.stderr) {
+        weatherProcess.stderr.on(`data`, chunk => {
+          console.error(chunk.toString());
+        });
+      }
+      if (weatherProcess.stdout) {
+        weatherProcess.stdout.on('data', chunk => {
+          if (chunk.toString().includes('server is running on SSE')) {
+            resolve();
+            resolved = true;
+          }
+        });
+      }
+    });
+  });
+
+  beforeEach(() => {
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleLogSpy.mockRestore();
+    vi.clearAllMocks();
+  });
+
+  afterAll(async () => {
+    // Kill the weather SSE server
+    weatherProcess.kill('SIGINT');
+  });
+
+  it('should log events from specific servers to their handlers', async () => {
+    // Create individual log handlers for each server
+    const weatherLogHandler = vi.fn();
+    const stockLogHandler = vi.fn();
+
+    const config = new MCPConfiguration({
+      id: 'server-log-test',
+      servers: {
+        weather: {
+          url: new URL('http://localhost:60809/sse'),
+          log: weatherLogHandler,
+        },
+        stock: {
+          command: 'npx',
+          args: ['-y', 'tsx', path.join(__dirname, '__fixtures__/stock-price.ts')],
+          env: {
+            FAKE_CREDS: 'test',
+          },
+          log: stockLogHandler,
+        },
+      },
+    });
+
+    await config.getTools();
+
+    // Verify weather logs went to weather handler only
+    expect(weatherLogHandler).toHaveBeenCalled();
+
+    // Check logs contain server name
+    const weatherLogs = weatherLogHandler.mock.calls.map(call => call[0]);
+    weatherLogs.forEach(log => {
+      expect(log).toMatchObject({
+        serverName: 'weather',
+        timestamp: expect.any(Date),
+      });
+    });
+
+    // Verify stock logs went to stock handler only
+    expect(stockLogHandler).toHaveBeenCalled();
+
+    // Check logs contain server name
+    const stockLogs = stockLogHandler.mock.calls.map(call => call[0]);
+    stockLogs.forEach(log => {
+      expect(log).toMatchObject({
+        serverName: 'stock',
+        timestamp: expect.any(Date),
+      });
+    });
+
+    // Clean up
+    await config.disconnect();
+  });
+
+  it('should work with handlers that filter events by log level', async () => {
+    // Create a handler that only logs errors and critical/emergency messages
+    const errorCounter = { count: 0 };
+    const highSeverityHandler = vi.fn((logMessage: LogMessage) => {
+      if (['error', 'critical', 'alert', 'emergency'].includes(logMessage.level)) {
+        errorCounter.count++;
+      }
+    });
+
+    // Intentionally use a non-existent command to generate errors
+    const config = new MCPConfiguration({
+      id: 'error-log-test',
+      servers: {
+        badServer: {
+          command: 'nonexistent-command-that-will-fail',
+          args: [],
+          log: highSeverityHandler,
+        },
+      },
+    });
+
+    // This should fail, but our logger should capture the error
+    try {
+      await config.getTools();
+    } catch {
+      // Expected to fail
+    }
+
+    // Verify error logger was called
+    expect(highSeverityHandler).toHaveBeenCalled();
+
+    // Check we logged at least one error
+    expect(errorCounter.count).toBeGreaterThan(0);
+
+    // Clean up
+    await config.disconnect();
+  });
+
+  it('should support console logging patterns', async () => {
+    const _logLevels: LoggingLevel[] = [
+      'debug',
+      'info',
+      'notice',
+      'warning',
+      'error',
+      'critical',
+      'alert',
+      'emergency',
+    ];
+    const logMessages: string[] = [];
+
+    const consoleLogger = (logMessage: LogMessage) => {
+      const formatted = `${logMessage.level}: ${logMessage.message}`;
+      logMessages.push(formatted);
+      console.log(formatted);
+    };
+
+    const config = new MCPConfiguration({
+      id: 'console-log-test',
+      servers: {
+        echoServer: {
+          command: 'echo',
+          args: ['test'],
+          log: consoleLogger,
+        },
+      },
+    });
+
+    try {
+      await config.getTools();
+    } catch {
+      // May fail, but we just care about logging
+    }
+
+    // Verify console.log was called
+    expect(consoleLogSpy).toHaveBeenCalled();
+
+    // Clean up
+    await config.disconnect();
+  });
+});