@mastra/mcp 0.3.10-alpha.0 → 0.3.10-alpha.2

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/mcp@0.3.10-alpha.0 build /home/runner/work/mastra/mastra/packages/mcp
+> @mastra/mcp@0.3.10-alpha.2 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 15149ms
+TSC ⚡️ Build success in 13988ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.8.2
 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.2
 Writing package typings: /home/runner/work/mastra/mastra/packages/mcp/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 11903ms
+DTS ⚡️ Build success in 10061ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 7.24 KB
-ESM ⚡️ Build success in 895ms
-CJS dist/index.cjs 7.27 KB
-CJS ⚡️ Build success in 895ms
+CJS dist/index.cjs 7.53 KB
+CJS ⚡️ Build success in 706ms
+ESM dist/index.js 7.48 KB
+ESM ⚡️ Build success in 706ms

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @mastra/mcp
 
+## 0.3.10-alpha.2
+
+### Patch Changes
+
+- Updated dependencies [0bcc862]
+  - @mastra/core@0.8.3-alpha.2
+
+## 0.3.10-alpha.1
+
+### Patch Changes
+
+- 37bb612: Add Elastic-2.0 licensing for packages
+- 3e8e000: Added configurable test timeouts to mcp configuration, and updated mcp version
+- 476ce7c: [MASTRA-2997] added documentation on authorization headers in sse connections
+- Updated dependencies [32e7b71]
+- Updated dependencies [37bb612]
+  - @mastra/core@0.8.3-alpha.1
+
 ## 0.3.10-alpha.0
 
 ### Patch Changes

package/{LICENSE → LICENSE.md}

@@ -1,4 +1,6 @@
-Elastic License 2.0 (ELv2)
+# Elastic License 2.0 (ELv2)
+
+Copyright (c) 2025 Mastra AI, Inc.
 
 **Acceptance**
 By using the software, you agree to all of the terms and conditions below.

package/README.md

@@ -37,6 +37,16 @@ const sseClient = new MastraMCPClient({
     requestInit: {
       headers: { Authorization: 'Bearer your-token' },
     },
+    eventSourceInit: {
+      fetch(input: Request | URL | string, init?: RequestInit) {
+        const headers = new Headers(init?.headers || {});
+        headers.set('Authorization', 'Bearer your-token');
+        return fetch(input, {
+          ...init,
+          headers,
+        });
+      },
+    },
   },
   timeout: 60000, // optional timeout for tool calls in milliseconds
 });
@@ -140,6 +150,16 @@ const mcp = new MCPConfiguration({
           Authorization: 'Bearer user-1-token',
         },
       },
+      eventSourceInit: {
+        fetch(input: Request | URL | string, init?: RequestInit) {
+          const headers = new Headers(init?.headers || {});
+          headers.set('Authorization', 'Bearer user-1-token');
+          return fetch(input, {
+            ...init,
+            headers,
+          });
+        },
+      },
     },
   },
 });
@@ -162,6 +182,44 @@ The `MCPConfiguration` class automatically:
 - Handles connection lifecycle and cleanup
 - Provides both flat and grouped access to tools
 
+## SSE Authentication and Headers
+
+When using SSE (Server-Sent Events) connections with authentication or custom headers, you need to configure headers in a specific way. The standard `requestInit` headers won't work alone because SSE connections use the browser's `EventSource` API, which doesn't support custom headers directly.
+
+The `eventSourceInit` configuration allows you to customize the underlying fetch request used for the SSE connection, ensuring your authentication headers are properly included.
+
+To properly include authentication headers or other custom headers in SSE connections, you need to use both `requestInit` and `eventSourceInit`:
+
+```typescript
+const sseClient = new MastraMCPClient({
+  name: 'authenticated-sse-client',
+  server: {
+    url: new URL('https://your-mcp-server.com/sse'),
+    // requestInit alone isn't enough for SSE connections
+    requestInit: {
+      headers: { Authorization: 'Bearer your-token' },
+    },
+    // eventSourceInit is required to include headers in the SSE connection
+    eventSourceInit: {
+      fetch(input: Request | URL | string, init?: RequestInit) {
+        const headers = new Headers(init?.headers || {});
+        headers.set('Authorization', 'Bearer your-token');
+        return fetch(input, {
+          ...init,
+          headers,
+        });
+      },
+    },
+  },
+});
+```
+
+This configuration ensures that:
+
+1. The authentication headers are properly included in the SSE connection request
+2. The connection can be established with the required credentials
+3. Subsequent messages can be received through the authenticated connection
+
 ## Configuration
 
 ### Required Parameters

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

@@ -2,7 +2,7 @@ import type { ClientCapabilities } from '@modelcontextprotocol/sdk/types.js';
 import { MastraBase } from '@mastra/core/base';
 import type { Protocol } from '@modelcontextprotocol/sdk/shared/protocol.js';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import type { SSEClientTransportOptions } from '@modelcontextprotocol/sdk/client/sse.js';
 import type { StdioServerParameters } from '@modelcontextprotocol/sdk/client/stdio.js';
 
 declare class MastraMCPClient extends MastraBase {
@@ -26,16 +26,18 @@ declare class MastraMCPClient extends MastraBase {
 export { MastraMCPClient }
 export { MastraMCPClient as MastraMCPClient_alias_1 }
 
-declare type MastraMCPServerDefinition = StdioServerParameters | SSEClientParameters;
+declare type MastraMCPServerDefinition = StdioServerParametersWithTimeout | SSEClientParameters;
 export { MastraMCPServerDefinition }
 export { MastraMCPServerDefinition as MastraMCPServerDefinition_alias_1 }
 
 declare class MCPConfiguration extends MastraBase {
     private serverConfigs;
     private id;
+    private defaultTimeout;
     constructor(args: {
         id?: string;
         servers: Record<string, MastraMCPServerDefinition>;
+        timeout?: number;
     });
     private addToInstanceCache;
     private makeId;
@@ -99,6 +101,11 @@ export declare const server_alias_1: Server<{
 
 declare type SSEClientParameters = {
     url: URL;
-} & ConstructorParameters<typeof SSEClientTransport>[1];
+    timeout?: number;
+} & SSEClientTransportOptions;
+
+declare type StdioServerParametersWithTimeout = StdioServerParameters & {
+    timeout?: number;
+};
 
 export { }

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

@@ -2,7 +2,7 @@ import type { ClientCapabilities } from '@modelcontextprotocol/sdk/types.js';
 import { MastraBase } from '@mastra/core/base';
 import type { Protocol } from '@modelcontextprotocol/sdk/shared/protocol.js';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import type { SSEClientTransportOptions } from '@modelcontextprotocol/sdk/client/sse.js';
 import type { StdioServerParameters } from '@modelcontextprotocol/sdk/client/stdio.js';
 
 declare class MastraMCPClient extends MastraBase {
@@ -26,16 +26,18 @@ declare class MastraMCPClient extends MastraBase {
 export { MastraMCPClient }
 export { MastraMCPClient as MastraMCPClient_alias_1 }
 
-declare type MastraMCPServerDefinition = StdioServerParameters | SSEClientParameters;
+declare type MastraMCPServerDefinition = StdioServerParametersWithTimeout | SSEClientParameters;
 export { MastraMCPServerDefinition }
 export { MastraMCPServerDefinition as MastraMCPServerDefinition_alias_1 }
 
 declare class MCPConfiguration extends MastraBase {
     private serverConfigs;
     private id;
+    private defaultTimeout;
     constructor(args: {
         id?: string;
         servers: Record<string, MastraMCPServerDefinition>;
+        timeout?: number;
     });
     private addToInstanceCache;
     private makeId;
@@ -99,6 +101,11 @@ export declare const server_alias_1: Server<{
 
 declare type SSEClientParameters = {
     url: URL;
-} & ConstructorParameters<typeof SSEClientTransport>[1];
+    timeout?: number;
+} & SSEClientTransportOptions;
+
+declare type StdioServerParametersWithTimeout = StdioServerParameters & {
+    timeout?: number;
+};
 
 export { }

package/dist/index.cjs

@@ -53,7 +53,9 @@ var MastraMCPClient = class extends base.MastraBase {
   async connect() {
     if (this.isConnected) return;
     try {
-      await this.client.connect(this.transport);
+      await this.client.connect(this.transport, {
+        timeout: this.timeout
+      });
       this.isConnected = true;
       const originalOnClose = this.client.onclose;
       this.client.onclose = () => {
@@ -84,10 +86,12 @@ ${e instanceof Error ? e.stack : JSON.stringify(e, null, 2)}`
   }
   // 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() {
-    return await this.client.request({ method: "resources/list" }, types_js.ListResourcesResultSchema);
+    return await this.client.request({ method: "resources/list" }, types_js.ListResourcesResultSchema, {
+      timeout: this.timeout
+    });
   }
   async tools() {
-    const { tools: tools$1 } = await this.client.listTools();
+    const { tools: tools$1 } = await this.client.listTools({ timeout: this.timeout });
     const toolsRes = {};
     tools$1.forEach((tool) => {
       const s = utils.jsonSchemaToModel(tool.inputSchema);
@@ -126,8 +130,10 @@ var mastraMCPConfigurationInstances = /* @__PURE__ */ new Map();
 var MCPConfiguration = class extends base.MastraBase {
   serverConfigs = {};
   id;
+  defaultTimeout;
   constructor(args) {
     super({ name: "MCPConfiguration" });
+    this.defaultTimeout = args.timeout ?? protocol_js.DEFAULT_REQUEST_TIMEOUT_MSEC;
     this.serverConfigs = args.servers;
     this.id = args.id ?? this.makeId();
     const existingInstance = mastraMCPConfigurationInstances.get(this.id);
@@ -198,7 +204,8 @@ To fix this you have three different options:
     this.logger.debug(`Connecting to ${name} MCP server`);
     const mcpClient = new MastraMCPClient({
       name,
-      server: config
+      server: config,
+      timeout: config.timeout ?? this.defaultTimeout
     });
     this.mcpClientsById.set(name, mcpClient);
     try {

package/dist/index.js

@@ -51,7 +51,9 @@ var MastraMCPClient = class extends MastraBase {
   async connect() {
     if (this.isConnected) return;
     try {
-      await this.client.connect(this.transport);
+      await this.client.connect(this.transport, {
+        timeout: this.timeout
+      });
       this.isConnected = true;
       const originalOnClose = this.client.onclose;
       this.client.onclose = () => {
@@ -82,10 +84,12 @@ ${e instanceof Error ? e.stack : JSON.stringify(e, null, 2)}`
   }
   // 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() {
-    return await this.client.request({ method: "resources/list" }, ListResourcesResultSchema);
+    return await this.client.request({ method: "resources/list" }, ListResourcesResultSchema, {
+      timeout: this.timeout
+    });
   }
   async tools() {
-    const { tools } = await this.client.listTools();
+    const { tools } = await this.client.listTools({ timeout: this.timeout });
     const toolsRes = {};
     tools.forEach((tool) => {
       const s = jsonSchemaToModel(tool.inputSchema);
@@ -124,8 +128,10 @@ var mastraMCPConfigurationInstances = /* @__PURE__ */ new Map();
 var MCPConfiguration = class extends MastraBase {
   serverConfigs = {};
   id;
+  defaultTimeout;
   constructor(args) {
     super({ name: "MCPConfiguration" });
+    this.defaultTimeout = args.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
     this.serverConfigs = args.servers;
     this.id = args.id ?? this.makeId();
     const existingInstance = mastraMCPConfigurationInstances.get(this.id);
@@ -196,7 +202,8 @@ To fix this you have three different options:
     this.logger.debug(`Connecting to ${name} MCP server`);
     const mcpClient = new MastraMCPClient({
       name,
-      server: config
+      server: config,
+      timeout: config.timeout ?? this.defaultTimeout
     });
     this.mcpClientsById.set(name, mcpClient);
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/mcp",
-  "version": "0.3.10-alpha.0",
+  "version": "0.3.10-alpha.2",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -20,13 +20,13 @@
   },
   "keywords": [],
   "author": "",
-  "license": "ISC",
+  "license": "Elastic-2.0",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.7.0",
+    "@modelcontextprotocol/sdk": "^1.9.0",
     "date-fns": "^4.1.0",
     "exit-hook": "^4.0.0",
     "uuid": "^11.1.0",
-    "@mastra/core": "^0.8.3-alpha.0"
+    "@mastra/core": "^0.8.3-alpha.2"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^1.1.15",
@@ -38,7 +38,7 @@
     "vitest": "^3.0.9",
     "zod": "^3.24.2",
     "zod-to-json-schema": "^3.22.4",
-    "@internal/lint": "0.0.1"
+    "@internal/lint": "0.0.2-alpha.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",

package/src/__fixtures__/weather.ts

@@ -1,5 +1,7 @@
+import type { IncomingMessage, ServerResponse } from 'http';
+import { createServer } from 'http';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
@@ -127,7 +129,57 @@ server.setRequestHandler(CallToolRequestSchema, async request => {
 });
 
 // Start the server
-const transport = new StdioServerTransport();
-await server.connect(transport);
+let transport: SSEServerTransport | undefined;
+
+const httpServer = createServer(async (req: IncomingMessage, res: ServerResponse) => {
+  const url = new URL(req.url || '', `http://${req.headers.host}`);
+
+  if (url.pathname === '/sse') {
+    console.log('Received SSE connection');
+    transport = new SSEServerTransport('/message', res);
+    await server.connect(transport);
+
+    server.onclose = async () => {
+      await server.close();
+      transport = undefined;
+    };
+
+    // Handle client disconnection
+    res.on('close', () => {
+      transport = undefined;
+    });
+  } else if (url.pathname === '/message') {
+    console.log('Received message');
+    if (!transport) {
+      res.writeHead(503);
+      res.end('SSE connection not established');
+      return;
+    }
+    await transport.handlePostMessage(req, res);
+  } else {
+    console.log('Unknown path:', url.pathname);
+    res.writeHead(404);
+    res.end();
+  }
+});
+
+const PORT = process.env.PORT || 60808;
+httpServer.listen(PORT, () => {
+  console.log(`Weather server is running on SSE at http://localhost:${PORT}`);
+});
+
+// Handle graceful shutdown
+process.on('SIGINT', async () => {
+  console.log('Shutting down weather server...');
+  if (transport) {
+    await server.close();
+    transport = undefined;
+  }
+  // Close the HTTP server
+  httpServer.close(() => {
+    console.log('Weather server shut down complete');
+    process.exit(0);
+  });
+});
 
 export { server };

package/src/client.ts

@@ -3,6 +3,7 @@ import { createTool } from '@mastra/core/tools';
 import { jsonSchemaToModel } from '@mastra/core/utils';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import type { SSEClientTransportOptions } from '@modelcontextprotocol/sdk/client/sse.js';
 import { getDefaultEnvironment, StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import type { StdioServerParameters } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { DEFAULT_REQUEST_TIMEOUT_MSEC } from '@modelcontextprotocol/sdk/shared/protocol.js';
@@ -13,11 +14,17 @@ import { CallToolResultSchema, ListResourcesResultSchema } from '@modelcontextpr
 
 import { asyncExitHook, gracefulExit } from 'exit-hook';
 
+// Omit the fields we want to control from the SDK options
 type SSEClientParameters = {
   url: URL;
-} & ConstructorParameters<typeof SSEClientTransport>[1];
+  timeout?: number;
+} & SSEClientTransportOptions;
 
-export type MastraMCPServerDefinition = StdioServerParameters | SSEClientParameters;
+type StdioServerParametersWithTimeout = StdioServerParameters & {
+  timeout?: number;
+};
+
+export type MastraMCPServerDefinition = StdioServerParametersWithTimeout | SSEClientParameters;
 
 export class MastraMCPClient extends MastraBase {
   name: string;
@@ -70,7 +77,9 @@ export class MastraMCPClient extends MastraBase {
   async connect() {
     if (this.isConnected) return;
     try {
-      await this.client.connect(this.transport);
+      await this.client.connect(this.transport, {
+        timeout: this.timeout,
+      });
       this.isConnected = true;
       const originalOnClose = this.client.onclose;
       this.client.onclose = () => {
@@ -104,11 +113,13 @@ export class MastraMCPClient extends MastraBase {
   // 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']>> {
-    return await this.client.request({ method: 'resources/list' }, ListResourcesResultSchema);
+    return await this.client.request({ method: 'resources/list' }, ListResourcesResultSchema, {
+      timeout: this.timeout,
+    });
   }
 
   async tools() {
-    const { tools } = await this.client.listTools();
+    const { tools } = await this.client.listTools({ timeout: this.timeout });
     const toolsRes: Record<string, any> = {};
     tools.forEach(tool => {
       const s = jsonSchemaToModel(tool.inputSchema);

package/src/configuration.test.ts

@@ -1,8 +1,10 @@
 import { spawn } from 'child_process';
 import path from 'path';
-import { describe, it, expect, beforeEach, afterEach, afterAll, beforeAll } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach, afterAll, beforeAll, vi } from 'vitest';
 import { MCPConfiguration } from './configuration';
 
+vi.setConfig({ testTimeout: 80000, hookTimeout: 80000 });
+
 describe('MCPConfiguration', () => {
   let mcp: MCPConfiguration;
   let weatherProcess: ReturnType<typeof spawn>;
@@ -178,4 +180,132 @@ describe('MCPConfiguration', () => {
       await existingConfig.disconnect();
     });
   });
+  describe('MCPConfiguration Operation Timeouts', () => {
+    it('should respect custom timeout in configuration', async () => {
+      const config = new MCPConfiguration({
+        id: 'test-timeout-config',
+        timeout: 3000, // 3 second timeout
+        servers: {
+          test: {
+            command: 'node',
+            args: [
+              '-e',
+              `
+            const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+            const server = new Server({ name: 'test', version: '1.0.0' });
+            setTimeout(() => process.exit(0), 2000); // 2 second delay
+          `,
+            ],
+          },
+        },
+      });
+
+      const error = await config.getTools().catch(e => e);
+      expect(error).toBeDefined(); // Will throw since server exits before responding
+      expect(error.message).not.toMatch(/Request timed out/);
+
+      await config.disconnect();
+    });
+
+    it('should respect per-server timeout override', async () => {
+      const config = new MCPConfiguration({
+        id: 'test-server-timeout-config',
+        timeout: 500, // Global timeout of 500ms
+        servers: {
+          test: {
+            command: 'node',
+            args: [
+              '-e',
+              `
+            const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+            const server = new Server({ name: 'test', version: '1.0.0' });
+            setTimeout(() => process.exit(0), 2000); // 2 second delay
+          `,
+            ],
+            timeout: 3000, // Server-specific timeout of 3s
+          },
+        },
+      });
+
+      // This should succeed since server timeout (3s) is longer than delay (2s)
+      const error = await config.getTools().catch(e => e);
+      expect(error).toBeDefined(); // Will throw since server exits before responding
+      expect(error.message).not.toMatch(/Request timed out/);
+
+      await config.disconnect();
+    });
+  });
+
+  describe('MCPConfiguration Connection Timeout', () => {
+    it('should throw timeout error for slow starting server', async () => {
+      const slowConfig = new MCPConfiguration({
+        id: 'test-slow-server',
+        servers: {
+          slowServer: {
+            command: 'node',
+            args: ['-e', 'setTimeout(() => process.exit(0), 65000)'], // Simulate a server that takes 65 seconds to start
+          },
+        },
+      });
+
+      await expect(slowConfig.getTools()).rejects.toThrow(/Request timed out/);
+      await slowConfig.disconnect();
+    });
+
+    it('timeout should be longer than default timeout', async () => {
+      const slowConfig = new MCPConfiguration({
+        id: 'test-slow-server',
+        timeout: 70000,
+        servers: {
+          slowServer: {
+            command: 'node',
+            args: ['-e', 'setTimeout(() => process.exit(0), 65000)'], // Simulate a server that takes 65 seconds to start
+          },
+        },
+      });
+
+      const error = await slowConfig.getTools().catch(e => e);
+      expect(error).toBeDefined();
+      expect(error.message).not.toMatch(/Request timed out/);
+      await slowConfig.disconnect();
+    });
+
+    it('should respect custom timeout configuration', async () => {
+      const quickConfig = new MCPConfiguration({
+        id: 'test-quick-timeout',
+        timeout: 1000, // Very short global timeout
+        servers: {
+          slowServer: {
+            command: 'node',
+            args: ['-e', 'setTimeout(() => process.exit(0), 30000)'], // Takes 30 seconds to exit
+          },
+        },
+      });
+
+      await expect(quickConfig.getTools()).rejects.toThrow(/Request timed out/);
+      await quickConfig.disconnect();
+    });
+
+    it('should respect per-server timeout configuration', async () => {
+      const mixedConfig = new MCPConfiguration({
+        id: 'test-mixed-timeout',
+        timeout: 1000, // Short global timeout
+        servers: {
+          quickServer: {
+            command: 'node',
+            args: ['-e', 'setTimeout(() => process.exit(0), 2000)'], // Takes 2 seconds to exit
+          },
+          slowServer: {
+            command: 'node',
+            args: ['-e', 'setTimeout(() => process.exit(0), 2000)'], // Takes 2 seconds to exit
+            timeout: 3000, // But has a longer timeout
+          },
+        },
+      });
+
+      // Quick server should timeout
+      await expect(mixedConfig.getTools()).rejects.toThrow(/Request timed out/);
+      await mixedConfig.disconnect();
+    });
+  });
 });

package/src/configuration.ts

@@ -1,4 +1,5 @@
 import { MastraBase } from '@mastra/core/base';
+import { DEFAULT_REQUEST_TIMEOUT_MSEC } from '@modelcontextprotocol/sdk/shared/protocol.js';
 import { v5 as uuidv5 } from 'uuid';
 import { MastraMCPClient } from './client';
 import type { MastraMCPServerDefinition } from './client';
@@ -8,9 +9,15 @@ const mastraMCPConfigurationInstances = new Map<string, InstanceType<typeof MCPC
 export class MCPConfiguration extends MastraBase {
   private serverConfigs: Record<string, MastraMCPServerDefinition> = {};
   private id: string;
+  private defaultTimeout: number;
 
-  constructor(args: { id?: string; servers: Record<string, MastraMCPServerDefinition> }) {
+  constructor(args: {
+    id?: string;
+    servers: Record<string, MastraMCPServerDefinition>;
+    timeout?: number; // Optional global timeout
+  }) {
     super({ name: 'MCPConfiguration' });
+    this.defaultTimeout = args.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
     this.serverConfigs = args.servers;
     this.id = args.id ?? this.makeId();
 
@@ -100,6 +107,7 @@ To fix this you have three different options:
     const mcpClient = new MastraMCPClient({
       name,
       server: config,
+      timeout: config.timeout ?? this.defaultTimeout,
     });
 
     this.mcpClientsById.set(name, mcpClient);