@mastra/mcp 0.5.0-alpha.4 → 0.5.0-alpha.5

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/mcp@0.5.0-alpha.4 build /home/runner/work/mastra/mastra/packages/mcp
+> @mastra/mcp@0.5.0-alpha.5 build /home/runner/work/mastra/mastra/packages/mcp
 > tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.4.0
 TSC Build start
-TSC ⚡️ Build success in 17734ms
+TSC ⚡️ Build success in 18682ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/packages/mcp/dist/_tsup-dts-rollup.d.ts
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/packages/mcp/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 13432ms
+DTS ⚡️ Build success in 14171ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs 32.44 KB
-CJS ⚡️ Build success in 1027ms
-ESM dist/index.js 32.14 KB
-ESM ⚡️ Build success in 1029ms
+CJS dist/index.cjs 32.75 KB
+CJS ⚡️ Build success in 1159ms
+ESM dist/index.js 32.45 KB
+ESM ⚡️ Build success in 1159ms

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @mastra/mcp
 
+## 0.5.0-alpha.5
+
+### Patch Changes
+
+- 8baa6c8: passes runtimeContext to the logger function inside MCPClient tool calls
+
 ## 0.5.0-alpha.4
 
 ### Patch Changes

package/dist/_tsup-dts-rollup.d.cts

@@ -7,6 +7,7 @@ import { MCPServerBase } from '@mastra/core/mcp';
 import type { MCPServerHonoSSEOptions } from '@mastra/core/mcp';
 import type { MCPServerSSEOptions } from '@mastra/core/mcp';
 import type { Protocol } from '@modelcontextprotocol/sdk/shared/protocol.js';
+import type { RuntimeContext } from '@mastra/core/di';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import type { SSEClientTransportOptions } from '@modelcontextprotocol/sdk/client/sse.js';
 import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
@@ -51,6 +52,7 @@ export declare class InternalMastraMCPClient extends MastraBase {
     private enableServerLogs?;
     private serverConfig;
     private transport?;
+    private currentOperationContext;
     constructor({ name, version, server, capabilities, timeout, }: InternalMastraMCPClientOptions);
     /**
      * Log a message at the specified level
@@ -105,6 +107,7 @@ declare interface LogMessage {
     timestamp: Date;
     serverName: string;
     details?: Record<string, any>;
+    runtimeContext?: RuntimeContext | null;
 }
 export { LogMessage }
 export { LogMessage as LogMessage_alias_1 }

package/dist/_tsup-dts-rollup.d.ts

@@ -7,6 +7,7 @@ import { MCPServerBase } from '@mastra/core/mcp';
 import type { MCPServerHonoSSEOptions } from '@mastra/core/mcp';
 import type { MCPServerSSEOptions } from '@mastra/core/mcp';
 import type { Protocol } from '@modelcontextprotocol/sdk/shared/protocol.js';
+import type { RuntimeContext } from '@mastra/core/di';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import type { SSEClientTransportOptions } from '@modelcontextprotocol/sdk/client/sse.js';
 import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
@@ -51,6 +52,7 @@ export declare class InternalMastraMCPClient extends MastraBase {
     private enableServerLogs?;
     private serverConfig;
     private transport?;
+    private currentOperationContext;
     constructor({ name, version, server, capabilities, timeout, }: InternalMastraMCPClientOptions);
     /**
      * Log a message at the specified level
@@ -105,6 +107,7 @@ declare interface LogMessage {
     timestamp: Date;
     serverName: string;
     details?: Record<string, any>;
+    runtimeContext?: RuntimeContext | null;
 }
 export { LogMessage }
 export { LogMessage as LogMessage_alias_1 }

package/dist/index.cjs

@@ -55,6 +55,7 @@ var InternalMastraMCPClient = class extends base.MastraBase {
   enableServerLogs;
   serverConfig;
   transport;
+  currentOperationContext = null;
   constructor({
     name,
     version = "1.0.0",
@@ -95,7 +96,8 @@ var InternalMastraMCPClient = class extends base.MastraBase {
         message: msg,
         timestamp: /* @__PURE__ */ new Date(),
         serverName: this.name,
-        details
+        details,
+        runtimeContext: this.currentOperationContext
       });
     }
   }
@@ -273,7 +275,9 @@ var InternalMastraMCPClient = class extends base.MastraBase {
           id: `${this.name}_${tool.name}`,
           description: tool.description || "",
           inputSchema: this.convertInputSchema(tool.inputSchema),
-          execute: async ({ context }) => {
+          execute: async ({ context, runtimeContext }) => {
+            const previousContext = this.currentOperationContext;
+            this.currentOperationContext = runtimeContext || null;
             try {
               this.log("debug", `Executing tool: ${tool.name}`, { toolArgs: context });
               const res = await this.client.callTool(
@@ -294,6 +298,8 @@ var InternalMastraMCPClient = class extends base.MastraBase {
                 toolArgs: context
               });
               throw e;
+            } finally {
+              this.currentOperationContext = previousContext;
             }
           }
         });

package/dist/index.js

@@ -49,6 +49,7 @@ var InternalMastraMCPClient = class extends MastraBase {
   enableServerLogs;
   serverConfig;
   transport;
+  currentOperationContext = null;
   constructor({
     name,
     version = "1.0.0",
@@ -89,7 +90,8 @@ var InternalMastraMCPClient = class extends MastraBase {
         message: msg,
         timestamp: /* @__PURE__ */ new Date(),
         serverName: this.name,
-        details
+        details,
+        runtimeContext: this.currentOperationContext
       });
     }
   }
@@ -267,7 +269,9 @@ var InternalMastraMCPClient = class extends MastraBase {
           id: `${this.name}_${tool.name}`,
           description: tool.description || "",
           inputSchema: this.convertInputSchema(tool.inputSchema),
-          execute: async ({ context }) => {
+          execute: async ({ context, runtimeContext }) => {
+            const previousContext = this.currentOperationContext;
+            this.currentOperationContext = runtimeContext || null;
             try {
               this.log("debug", `Executing tool: ${tool.name}`, { toolArgs: context });
               const res = await this.client.callTool(
@@ -288,6 +292,8 @@ var InternalMastraMCPClient = class extends MastraBase {
                 toolArgs: context
               });
               throw e;
+            } finally {
+              this.currentOperationContext = previousContext;
             }
           }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/mcp",
-  "version": "0.5.0-alpha.4",
+  "version": "0.5.0-alpha.5",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -36,6 +36,7 @@
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^1.1.15",
+    "@ai-sdk/openai": "^1.3.22",
     "@hono/node-server": "^1.13.8",
     "@mendable/firecrawl-js": "^1.24.0",
     "@microsoft/api-extractor": "^7.52.5",

package/src/client.ts

@@ -1,4 +1,5 @@
 import { MastraBase } from '@mastra/core/base';
+import type { RuntimeContext } from '@mastra/core/di';
 import { createTool } from '@mastra/core/tools';
 import { isZodType } from '@mastra/core/utils';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
@@ -27,6 +28,7 @@ export interface LogMessage {
   timestamp: Date;
   serverName: string;
   details?: Record<string, any>;
+  runtimeContext?: RuntimeContext | null;
 }
 
 export type LogHandler = (logMessage: LogMessage) => void;
@@ -107,6 +109,7 @@ export class InternalMastraMCPClient extends MastraBase {
   private enableServerLogs?: boolean;
   private serverConfig: MastraMCPServerDefinition;
   private transport?: Transport;
+  private currentOperationContext: RuntimeContext | null = null;
 
   constructor({
     name,
@@ -159,6 +162,7 @@ export class InternalMastraMCPClient extends MastraBase {
         timestamp: new Date(),
         serverName: this.name,
         details,
+        runtimeContext: this.currentOperationContext,
       });
     }
   }
@@ -365,7 +369,9 @@ export class InternalMastraMCPClient extends MastraBase {
           id: `${this.name}_${tool.name}`,
           description: tool.description || '',
           inputSchema: this.convertInputSchema(tool.inputSchema),
-          execute: async ({ context }) => {
+          execute: async ({ context, runtimeContext }: { context: any; runtimeContext?: RuntimeContext | null }) => {
+            const previousContext = this.currentOperationContext;
+            this.currentOperationContext = runtimeContext || null; // Set current context
             try {
               this.log('debug', `Executing tool: ${tool.name}`, { toolArgs: context });
               const res = await this.client.callTool(
@@ -386,6 +392,8 @@ export class InternalMastraMCPClient extends MastraBase {
                 toolArgs: context,
               });
               throw e;
+            } finally {
+              this.currentOperationContext = previousContext; // Restore previous context
             }
           },
         });

package/src/configuration.test.ts

@@ -1,8 +1,11 @@
 import { spawn } from 'child_process';
 import path from 'path';
+import { openai } from '@ai-sdk/openai';
+import { Agent } from '@mastra/core/agent';
+import { RuntimeContext } from '@mastra/core/di';
 import { describe, it, expect, beforeEach, afterEach, afterAll, beforeAll, vi } from 'vitest';
 import { allTools, mcpServerName } from './__fixtures__/fire-crawl-complex-schema';
-import type { LogHandler } from './client';
+import type { LogHandler, LogMessage } from './client';
 import { MCPClient } from './configuration';
 
 vi.setConfig({ testTimeout: 80000, hookTimeout: 80000 });
@@ -10,6 +13,7 @@ vi.setConfig({ testTimeout: 80000, hookTimeout: 80000 });
 describe('MCPClient', () => {
   let mcp: MCPClient;
   let weatherProcess: ReturnType<typeof spawn>;
+  let clients: MCPClient[] = [];
 
   beforeAll(async () => {
     // Start the weather SSE server
@@ -52,11 +56,16 @@ describe('MCPClient', () => {
         },
       },
     });
+    clients.push(mcp);
   });
 
   afterEach(async () => {
     // Clean up any connected clients
     await mcp.disconnect();
+    const index = clients.indexOf(mcp);
+    if (index > -1) {
+      clients.splice(index, 1);
+    }
   });
 
   afterAll(async () => {
@@ -394,4 +403,230 @@ describe('MCPClient', () => {
       expect(mockLogHandler.mock.calls.length).toBeGreaterThan(0);
     });
   });
+
+  describe('MCPClient Configuration', () => {
+    let clientsToCleanup: MCPClient[] = [];
+
+    afterEach(async () => {
+      await Promise.all(
+        clientsToCleanup.map(client =>
+          client.disconnect().catch(e => console.error(`Error disconnecting client during test cleanup: ${e}`)),
+        ),
+      );
+      clientsToCleanup = []; // Reset for the next test
+    });
+
+    it('should pass runtimeContext to the server logger function during tool execution', async () => {
+      type TestContext = { channel: string; userId: string };
+      const testContextInstance = new RuntimeContext<TestContext>();
+      testContextInstance.set('channel', 'test-channel-123');
+      testContextInstance.set('userId', 'user-abc-987');
+      const loggerFn = vi.fn();
+
+      const clientForTest = new MCPClient({
+        servers: {
+          stockPrice: {
+            command: 'npx',
+            args: ['tsx', path.join(__dirname, '__fixtures__/stock-price.ts')],
+            env: { FAKE_CREDS: 'test' },
+            logger: loggerFn,
+          },
+        },
+      });
+      clientsToCleanup.push(clientForTest);
+
+      const tools = await clientForTest.getTools();
+      const stockTool = tools['stockPrice_getStockPrice'];
+      expect(stockTool).toBeDefined();
+
+      await stockTool.execute({
+        context: { symbol: 'MSFT' },
+        runtimeContext: testContextInstance,
+      });
+
+      expect(loggerFn).toHaveBeenCalled();
+      const callWithContext = loggerFn.mock.calls.find(call => {
+        const logMessage = call[0] as LogMessage;
+        return (
+          logMessage.runtimeContext &&
+          typeof logMessage.runtimeContext.get === 'function' &&
+          logMessage.runtimeContext.get('channel') === 'test-channel-123' &&
+          logMessage.runtimeContext.get('userId') === 'user-abc-987'
+        );
+      });
+      expect(callWithContext).toBeDefined();
+      const capturedLogMessage = callWithContext?.[0] as LogMessage;
+      expect(capturedLogMessage?.serverName).toEqual('stockPrice');
+    }, 15000);
+
+    it('should pass runtimeContext to MCP logger when tool is called via an Agent', async () => {
+      type TestAgentContext = { traceId: string; tenant: string };
+      const agentTestContext = new RuntimeContext<TestAgentContext>();
+      agentTestContext.set('traceId', 'agent-trace-xyz');
+      agentTestContext.set('tenant', 'acme-corp');
+      const loggerFn = vi.fn();
+
+      const mcpClientForAgentTest = new MCPClient({
+        id: 'mcp-for-agent-test-suite',
+        servers: {
+          stockPriceServer: {
+            command: 'npx',
+            args: ['tsx', path.join(__dirname, '__fixtures__/stock-price.ts')],
+            env: { FAKE_CREDS: 'test' },
+            logger: loggerFn,
+          },
+        },
+      });
+      clientsToCleanup.push(mcpClientForAgentTest);
+
+      const agentName = 'stockAgentForContextTest';
+      const agent = new Agent({
+        name: agentName,
+        model: openai('gpt-4o'),
+        instructions: 'Use the getStockPrice tool to find the price of MSFT.',
+        tools: await mcpClientForAgentTest.getTools(),
+      });
+
+      await agent.generate('What is the price of MSFT?', { runtimeContext: agentTestContext });
+
+      expect(loggerFn).toHaveBeenCalled();
+      const callWithAgentContext = loggerFn.mock.calls.find(call => {
+        const logMessage = call[0] as LogMessage;
+        return (
+          logMessage.runtimeContext &&
+          typeof logMessage.runtimeContext.get === 'function' &&
+          logMessage.runtimeContext.get('traceId') === 'agent-trace-xyz' &&
+          logMessage.runtimeContext.get('tenant') === 'acme-corp'
+        );
+      });
+      expect(callWithAgentContext).toBeDefined();
+      if (callWithAgentContext) {
+        const capturedLogMessage = callWithAgentContext[0] as LogMessage;
+        expect(capturedLogMessage?.serverName).toEqual('stockPriceServer');
+      }
+    }, 20000);
+
+    it('should correctly use different runtimeContexts on sequential direct tool calls', async () => {
+      const loggerFn = vi.fn();
+      const clientForSeqTest = new MCPClient({
+        id: 'mcp-sequential-context-test',
+        servers: {
+          stockPriceServer: {
+            command: 'npx',
+            args: ['tsx', path.join(__dirname, '__fixtures__/stock-price.ts')],
+            env: { FAKE_CREDS: 'test' },
+            logger: loggerFn,
+          },
+        },
+      });
+      clientsToCleanup.push(clientForSeqTest);
+
+      const tools = await clientForSeqTest.getTools();
+      const stockTool = tools['stockPriceServer_getStockPrice'];
+      expect(stockTool).toBeDefined();
+
+      type ContextA = { callId: string };
+      const runtimeContextA = new RuntimeContext<ContextA>();
+      runtimeContextA.set('callId', 'call-A-111');
+      await stockTool.execute({ context: { symbol: 'MSFT' }, runtimeContext: runtimeContextA });
+
+      expect(loggerFn).toHaveBeenCalled();
+      let callsAfterA = [...loggerFn.mock.calls];
+      const logCallForA = callsAfterA.find(
+        call => (call[0] as LogMessage).runtimeContext?.get('callId') === 'call-A-111',
+      );
+      expect(logCallForA).toBeDefined();
+      expect((logCallForA?.[0] as LogMessage)?.runtimeContext?.get('callId')).toBe('call-A-111');
+
+      loggerFn.mockClear();
+
+      type ContextB = { sessionId: string };
+      const runtimeContextB = new RuntimeContext<ContextB>();
+      runtimeContextB.set('sessionId', 'session-B-222');
+      await stockTool.execute({ context: { symbol: 'GOOG' }, runtimeContext: runtimeContextB });
+
+      expect(loggerFn).toHaveBeenCalled();
+      let callsAfterB = [...loggerFn.mock.calls];
+      const logCallForB = callsAfterB.find(
+        call => (call[0] as LogMessage).runtimeContext?.get('sessionId') === 'session-B-222',
+      );
+      expect(logCallForB).toBeDefined();
+      expect((logCallForB?.[0] as LogMessage)?.runtimeContext?.get('sessionId')).toBe('session-B-222');
+
+      const contextALeak = callsAfterB.some(
+        call => (call[0] as LogMessage).runtimeContext?.get('callId') === 'call-A-111',
+      );
+      expect(contextALeak).toBe(false);
+    }, 20000);
+
+    it('should isolate runtimeContext between different servers on the same MCPClient', async () => {
+      const sharedLoggerFn = vi.fn();
+
+      const clientWithTwoServers = new MCPClient({
+        id: 'mcp-multi-server-context-isolation',
+        servers: {
+          serverX: {
+            command: 'npx',
+            args: ['tsx', path.join(__dirname, '__fixtures__/stock-price.ts')], // Re-use fixture, tool name will differ by server
+            logger: sharedLoggerFn,
+            env: { FAKE_CREDS: 'serverX-creds' }, // Make env slightly different for clarity if needed
+          },
+          serverY: {
+            command: 'npx',
+            args: ['tsx', path.join(__dirname, '__fixtures__/stock-price.ts')], // Re-use fixture
+            logger: sharedLoggerFn,
+            env: { FAKE_CREDS: 'serverY-creds' },
+          },
+        },
+      });
+      clientsToCleanup.push(clientWithTwoServers);
+
+      const tools = await clientWithTwoServers.getTools();
+      const toolX = tools['serverX_getStockPrice'];
+      const toolY = tools['serverY_getStockPrice'];
+      expect(toolX).toBeDefined();
+      expect(toolY).toBeDefined();
+
+      // --- Call tool on Server X with contextX ---
+      type ContextX = { requestId: string };
+      const runtimeContextX = new RuntimeContext<ContextX>();
+      runtimeContextX.set('requestId', 'req-X-001');
+
+      await toolX.execute({ context: { symbol: 'AAA' }, runtimeContext: runtimeContextX });
+
+      expect(sharedLoggerFn).toHaveBeenCalled();
+      let callsAfterToolX = [...sharedLoggerFn.mock.calls];
+      const logCallForX = callsAfterToolX.find(call => {
+        const logMessage = call[0] as LogMessage;
+        return logMessage.serverName === 'serverX' && logMessage.runtimeContext?.get('requestId') === 'req-X-001';
+      });
+      expect(logCallForX).toBeDefined();
+      expect((logCallForX?.[0] as LogMessage)?.runtimeContext?.get('requestId')).toBe('req-X-001');
+
+      sharedLoggerFn.mockClear(); // Clear for next distinct operation
+
+      // --- Call tool on Server Y with contextY ---
+      type ContextY = { customerId: string };
+      const runtimeContextY = new RuntimeContext<ContextY>();
+      runtimeContextY.set('customerId', 'cust-Y-002');
+
+      await toolY.execute({ context: { symbol: 'BBB' }, runtimeContext: runtimeContextY });
+
+      expect(sharedLoggerFn).toHaveBeenCalled();
+      let callsAfterToolY = [...sharedLoggerFn.mock.calls];
+      const logCallForY = callsAfterToolY.find(call => {
+        const logMessage = call[0] as LogMessage;
+        return logMessage.serverName === 'serverY' && logMessage.runtimeContext?.get('customerId') === 'cust-Y-002';
+      });
+      expect(logCallForY).toBeDefined();
+      expect((logCallForY?.[0] as LogMessage)?.runtimeContext?.get('customerId')).toBe('cust-Y-002');
+
+      // Ensure contextX did not leak into logs from serverY's operation
+      const contextXLeakInYLogs = callsAfterToolY.some(call => {
+        const logMessage = call[0] as LogMessage;
+        return logMessage.runtimeContext?.get('requestId') === 'req-X-001';
+      });
+      expect(contextXLeakInYLogs).toBe(false);
+    }, 25000); // Increased timeout for multiple server ops
+  });
 });