@mastra/mcp 0.10.2 → 0.10.3

package/src/client/client.ts

@@ -11,7 +11,7 @@ import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/
 import type { StreamableHTTPClientTransportOptions } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { DEFAULT_REQUEST_TIMEOUT_MSEC } from '@modelcontextprotocol/sdk/shared/protocol.js';
 import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
-import type { ClientCapabilities, LoggingLevel } from '@modelcontextprotocol/sdk/types.js';
+import type { ClientCapabilities, GetPromptResult, ListPromptsResult, LoggingLevel } from '@modelcontextprotocol/sdk/types.js';
 import {
   CallToolResultSchema,
   ListResourcesResultSchema,
@@ -19,12 +19,16 @@ import {
   ResourceListChangedNotificationSchema,
   ResourceUpdatedNotificationSchema,
   ListResourceTemplatesResultSchema,
+  ListPromptsResultSchema,
+  GetPromptResultSchema,
+  PromptListChangedNotificationSchema,
 } from '@modelcontextprotocol/sdk/types.js';
 
 import { asyncExitHook, gracefulExit } from 'exit-hook';
 import { z } from 'zod';
 import { convertJsonSchemaToZod } from 'zod-from-json-schema';
 import type { JSONSchema } from 'zod-from-json-schema';
+import { PromptClientActions } from './promptActions';
 import { ResourceClientActions } from './resourceActions';
 
 // Re-export MCP SDK LoggingLevel for convenience
@@ -119,6 +123,7 @@ export class InternalMastraMCPClient extends MastraBase {
   private transport?: Transport;
   private currentOperationContext: RuntimeContext | null = null;
   public readonly resources: ResourceClientActions;
+  public readonly prompts: PromptClientActions;
 
   constructor({
     name,
@@ -148,6 +153,7 @@ export class InternalMastraMCPClient extends MastraBase {
     this.setupLogging();
     
     this.resources = new ResourceClientActions({ client: this, logger: this.logger });
+    this.prompts = new PromptClientActions({ client: this, logger: this.logger });
   }
 
   /**
@@ -363,6 +369,42 @@ export class InternalMastraMCPClient extends MastraBase {
     });
   }
 
+  /**
+   * Fetch the list of available prompts from the MCP server.
+   */
+  async listPrompts(): Promise<ListPromptsResult> {
+    this.log('debug', `Requesting prompts from MCP server`);
+    return await this.client.request({ method: 'prompts/list' }, ListPromptsResultSchema, {
+      timeout: this.timeout,
+    });
+  }
+
+  /**
+   * Get a prompt and its dynamic messages from the server.
+   * @param name The prompt name
+   * @param args Arguments for the prompt
+   * @param version (optional) The prompt version to retrieve
+   */
+  async getPrompt({ name, args, version }: { name: string; args?: Record<string, any>; version?: string }): Promise<GetPromptResult> {
+    this.log('debug', `Requesting prompt from MCP server: ${name}`);
+    return await this.client.request(
+      { method: 'prompts/get', params: { name, arguments: args, version } },
+      GetPromptResultSchema,
+      { timeout: this.timeout }
+    );
+  }
+
+  /**
+   * Register a handler to be called when the prompt list changes on the server.
+   * Use this to refresh cached prompt lists in the client/UI if needed.
+   */
+  setPromptListChangedNotificationHandler(handler: () => void): void {
+    this.log('debug', 'Setting prompt list changed notification handler');
+    this.client.setNotificationHandler(PromptListChangedNotificationSchema, () => {
+      handler();
+    });
+  }
+
   setResourceUpdatedNotificationHandler(
     handler: (params: z.infer<typeof ResourceUpdatedNotificationSchema>['params']) => void,
   ): void {

package/src/client/configuration.test.ts

@@ -81,219 +81,317 @@ describe('MCPClient', () => {
     weatherProcess.kill('SIGINT');
   });
 
-  it('should initialize with server configurations', () => {
-    expect(mcp['serverConfigs']).toEqual({
-      stockPrice: {
-        command: 'npx',
-        args: ['-y', 'tsx', path.join(__dirname, '..', '__fixtures__/stock-price.ts')],
+  describe('Instance Management', () => {
+    it('should initialize with server configurations', () => {
+      expect(mcp['serverConfigs']).toEqual({
+        stockPrice: {
+          command: 'npx',
+          args: ['-y', 'tsx', path.join(__dirname, '..', '__fixtures__/stock-price.ts')],
         env: {
           FAKE_CREDS: 'test',
         },
-      },
-      weather: {
-        url: new URL(`http://localhost:${weatherServerPort}/sse`),
-      },
+        },
+        weather: {
+          url: new URL(`http://localhost:${weatherServerPort}/sse`),
+        },
+      });
     });
-  });
 
-  it('should get connected tools with namespaced tool names', async () => {
-    const connectedTools = await mcp.getTools();
+    it('should get connected tools with namespaced tool names', async () => {
+      const connectedTools = await mcp.getTools();
 
-    // Each tool should be namespaced with its server name
-    expect(connectedTools).toHaveProperty('stockPrice_getStockPrice');
-    expect(connectedTools).toHaveProperty('weather_getWeather');
-  });
+      // Each tool should be namespaced with its server name
+      expect(connectedTools).toHaveProperty('stockPrice_getStockPrice');
+      expect(connectedTools).toHaveProperty('weather_getWeather');
+    });
 
-  it('should get connected toolsets grouped by server', async () => {
-    const connectedToolsets = await mcp.getToolsets();
+    it('should get connected toolsets grouped by server', async () => {
+      const connectedToolsets = await mcp.getToolsets();
 
-    expect(connectedToolsets).toHaveProperty('stockPrice');
-    expect(connectedToolsets).toHaveProperty('weather');
-    expect(connectedToolsets.stockPrice).toHaveProperty('getStockPrice');
-    expect(connectedToolsets.weather).toHaveProperty('getWeather');
+      expect(connectedToolsets).toHaveProperty('stockPrice');
+      expect(connectedToolsets).toHaveProperty('weather');
+      expect(connectedToolsets.stockPrice).toHaveProperty('getStockPrice');
+      expect(connectedToolsets.weather).toHaveProperty('getWeather');
+    });
   });
 
-  it('should get resources from connected MCP servers', async () => {
-    const resources = await mcp.resources.list();
-
-    expect(resources).toHaveProperty('weather');
-    expect(resources.weather).toBeDefined();
-    expect(resources.weather).toHaveLength(3);
-
-    // Verify that each expected resource exists with the correct structure
-    const weatherResources = resources.weather;
-    const currentWeather = weatherResources.find(r => r.uri === 'weather://current');
-    expect(currentWeather).toBeDefined();
-    expect(currentWeather).toMatchObject({
-      uri: 'weather://current',
-      name: 'Current Weather Data',
-      description: expect.any(String),
-      mimeType: 'application/json',
+  describe('Resources', () => {
+    it('should get resources from connected MCP servers', async () => {
+      const resources = await mcp.resources.list();
+
+      expect(resources).toHaveProperty('weather');
+      expect(resources.weather).toBeDefined();
+      expect(resources.weather).toHaveLength(3);
+
+      // Verify that each expected resource exists with the correct structure
+      const weatherResources = resources.weather;
+      const currentWeather = weatherResources.find(r => r.uri === 'weather://current');
+      expect(currentWeather).toBeDefined();
+      expect(currentWeather).toMatchObject({
+        uri: 'weather://current',
+        name: 'Current Weather Data',
+        description: expect.any(String),
+        mimeType: 'application/json',
+      });
+
+      const forecast = weatherResources.find(r => r.uri === 'weather://forecast');
+      expect(forecast).toBeDefined();
+      expect(forecast).toMatchObject({
+        uri: 'weather://forecast',
+        name: 'Weather Forecast',
+        description: expect.any(String),
+        mimeType: 'application/json',
+      });
+
+      const historical = weatherResources.find(r => r.uri === 'weather://historical');
+      expect(historical).toBeDefined();
+      expect(historical).toMatchObject({
+        uri: 'weather://historical',
+        name: 'Historical Weather Data',
+        description: expect.any(String),
+        mimeType: 'application/json',
+      });
     });
 
-    const forecast = weatherResources.find(r => r.uri === 'weather://forecast');
-    expect(forecast).toBeDefined();
-    expect(forecast).toMatchObject({
-      uri: 'weather://forecast',
-      name: 'Weather Forecast',
-      description: expect.any(String),
-      mimeType: 'application/json',
+    it('should list resource templates from connected MCP servers', async () => {
+      const templates = await mcp.resources.templates();
+      expect(templates).toHaveProperty('weather');
+      expect(templates.weather).toBeDefined();
+      expect(templates.weather.length).toBeGreaterThan(0);
+      const customForecastTemplate = templates.weather.find(
+        (t: ResourceTemplate) => t.uriTemplate === 'weather://custom/{city}/{days}',
+      );
+      expect(customForecastTemplate).toBeDefined();
+      expect(customForecastTemplate).toMatchObject({
+        uriTemplate: 'weather://custom/{city}/{days}',
+        name: 'Custom Weather Forecast',
+        description: expect.any(String),
+        mimeType: 'application/json',
+      });
     });
 
-    const historical = weatherResources.find(r => r.uri === 'weather://historical');
-    expect(historical).toBeDefined();
-    expect(historical).toMatchObject({
-      uri: 'weather://historical',
-      name: 'Historical Weather Data',
-      description: expect.any(String),
-      mimeType: 'application/json',
+    it('should read a specific resource from a server', async () => {
+      const resourceContent = await mcp.resources.read('weather', 'weather://current');
+      expect(resourceContent).toBeDefined();
+      expect(resourceContent.contents).toBeInstanceOf(Array);
+      expect(resourceContent.contents.length).toBe(1);
+      const contentItem = resourceContent.contents[0];
+      expect(contentItem.uri).toBe('weather://current');
+      expect(contentItem.mimeType).toBe('application/json');
+      expect(contentItem.text).toBeDefined();
+      let parsedText: any = {};
+      if (contentItem.text && typeof contentItem.text === 'string') {
+        try {
+          parsedText = JSON.parse(contentItem.text);
+        } catch {
+          // If parsing fails, parsedText remains an empty object
+          // console.error("Failed to parse resource content text:", _e);
+        }
+      }
+      expect(parsedText).toHaveProperty('location');
     });
-  });
 
-  it('should list resource templates from connected MCP servers', async () => {
-    const templates = await mcp.resources.templates();
-    expect(templates).toHaveProperty('weather');
-    expect(templates.weather).toBeDefined();
-    expect(templates.weather.length).toBeGreaterThan(0);
-    const customForecastTemplate = templates.weather.find(
-      (t: ResourceTemplate) => t.uriTemplate === 'weather://custom/{city}/{days}',
-    );
-    expect(customForecastTemplate).toBeDefined();
-    expect(customForecastTemplate).toMatchObject({
-      uriTemplate: 'weather://custom/{city}/{days}',
-      name: 'Custom Weather Forecast',
-      description: expect.any(String),
-      mimeType: 'application/json',
+    it('should subscribe and unsubscribe from a resource on a specific server', async () => {
+      const serverName = 'weather';
+      const resourceUri = 'weather://current';
+
+      const subResult = await mcp.resources.subscribe(serverName, resourceUri);
+      expect(subResult).toEqual({});
+
+      const unsubResult = await mcp.resources.unsubscribe(serverName, resourceUri);
+      expect(unsubResult).toEqual({});
     });
-  });
 
-  it('should read a specific resource from a server', async () => {
-    const resourceContent = await mcp.resources.read('weather', 'weather://current');
-    expect(resourceContent).toBeDefined();
-    expect(resourceContent.contents).toBeInstanceOf(Array);
-    expect(resourceContent.contents.length).toBe(1);
-    const contentItem = resourceContent.contents[0];
-    expect(contentItem.uri).toBe('weather://current');
-    expect(contentItem.mimeType).toBe('application/json');
-    expect(contentItem.text).toBeDefined();
-    let parsedText: any = {};
-    if (contentItem.text && typeof contentItem.text === 'string') {
-      try {
-        parsedText = JSON.parse(contentItem.text);
-      } catch {
-        // If parsing fails, parsedText remains an empty object
-        // console.error("Failed to parse resource content text:", _e);
-      }
-    }
-    expect(parsedText).toHaveProperty('location');
-  });
+    it('should receive resource updated notification from a specific server', async () => {
+      const serverName = 'weather';
+      const resourceUri = 'weather://current';
+      let notificationReceived = false;
+      let receivedUri = '';
+
+      await mcp.resources.list(); // Initial call to establish connection if needed
+      // Create the promise for the notification BEFORE subscribing
+      const resourceUpdatedPromise = new Promise<void>((resolve, reject) => {
+        mcp.resources.onUpdated(serverName, (params: { uri: string }) => {
+          if (params.uri === resourceUri) {
+            notificationReceived = true;
+            receivedUri = params.uri;
+            resolve();
+          } else {
+            console.log(`[Test LOG] Received update for ${params.uri}, waiting for ${resourceUri}`);
+          }
+        });
+        setTimeout(() => reject(new Error(`Timeout waiting for resourceUpdated notification for ${resourceUri}`)), 4500);
+      });
 
-  it('should subscribe and unsubscribe from a resource on a specific server', async () => {
-    const serverName = 'weather';
-    const resourceUri = 'weather://current';
+      await mcp.resources.subscribe(serverName, resourceUri); // Ensure subscription is active
 
-    const subResult = await mcp.resources.subscribe(serverName, resourceUri);
-    expect(subResult).toEqual({});
+      await expect(resourceUpdatedPromise).resolves.toBeUndefined(); // Wait for the notification
 
-    const unsubResult = await mcp.resources.unsubscribe(serverName, resourceUri);
-    expect(unsubResult).toEqual({});
-  });
+      expect(notificationReceived).toBe(true);
+      expect(receivedUri).toBe(resourceUri);
+
+      await mcp.resources.unsubscribe(serverName, resourceUri); // Cleanup
+    }, 5000);
+
+    it('should receive resource list changed notification from a specific server', async () => {
+      const serverName = 'weather';
+      let notificationReceived = false;
 
-  it('should receive resource updated notification from a specific server', async () => {
-    const serverName = 'weather';
-    const resourceUri = 'weather://current';
-    let notificationReceived = false;
-    let receivedUri = '';
-
-    await mcp.resources.list(); // Initial call to establish connection if needed
-    // Create the promise for the notification BEFORE subscribing
-    const resourceUpdatedPromise = new Promise<void>((resolve, reject) => {
-      mcp.resources.onUpdated(serverName, (params: { uri: string }) => {
-        if (params.uri === resourceUri) {
+      await mcp.resources.list(); // Initial call to establish connection
+
+      const resourceListChangedPromise = new Promise<void>((resolve, reject) => {
+        mcp.resources.onListChanged(serverName, () => {
           notificationReceived = true;
-          receivedUri = params.uri;
           resolve();
-        } else {
-          console.log(`[Test LOG] Received update for ${params.uri}, waiting for ${resourceUri}`);
-        }
+        });
+        setTimeout(() => reject(new Error('Timeout waiting for resourceListChanged notification')), 4500);
       });
-      setTimeout(() => reject(new Error(`Timeout waiting for resourceUpdated notification for ${resourceUri}`)), 4500);
+
+      // In a real scenario, something would trigger the server to send this.
+      // For the test, we rely on the interval in weather.ts or a direct call if available.
+      // Adding a small delay or an explicit trigger if the fixture supported it would be more robust.
+      // For now, we assume the interval in weather.ts will eventually fire it.
+
+      await expect(resourceListChangedPromise).resolves.toBeUndefined(); // Wait for the notification
+
+      expect(notificationReceived).toBe(true);
     });
 
-    await mcp.resources.subscribe(serverName, resourceUri); // Ensure subscription is active
+    it('should handle errors when getting resources', async () => {
+      const errorClient = new MCPClient({
+        id: 'error-test-client',
+        servers: {
+          weather: {
+            url: new URL(`http://localhost:${weatherServerPort}/sse`),
+          },
+          nonexistentServer: {
+            command: 'nonexistent-command',
+            args: [],
+          },
+        },
+      });
 
-    await expect(resourceUpdatedPromise).resolves.toBeUndefined(); // Wait for the notification
+      try {
+        const resources = await errorClient.resources.list();
 
-    expect(notificationReceived).toBe(true);
-    expect(receivedUri).toBe(resourceUri);
+        expect(resources).toHaveProperty('weather');
+        expect(resources.weather).toBeDefined();
+        expect(resources.weather.length).toBeGreaterThan(0);
 
-    await mcp.resources.unsubscribe(serverName, resourceUri); // Cleanup
-  }, 5000);
+        expect(resources).not.toHaveProperty('nonexistentServer');
+      } finally {
+        await errorClient.disconnect();
+      }
+    });
+  })
+
+  describe('Prompts', () => {
+    it('should get prompts from connected MCP servers', async () => {
+      const prompts = await mcp.prompts.list();
+
+      expect(prompts).toHaveProperty('weather');
+      expect(prompts['weather']).toBeDefined();
+      expect(prompts['weather']).toHaveLength(3);
+
+      // Verify that each expected resource exists with the correct structure
+      const promptResources = prompts['weather'];
+      const currentWeatherPrompt = promptResources.find(r => r.name === 'current');
+      expect(currentWeatherPrompt).toBeDefined();
+      expect(currentWeatherPrompt).toMatchObject({
+        name: 'current',
+        version: 'v1',
+        description: expect.any(String),
+        mimeType: 'application/json',
+      });
 
-  it('should receive resource list changed notification from a specific server', async () => {
-    const serverName = 'weather';
-    let notificationReceived = false;
+      const forecast = promptResources.find(r => r.name === 'forecast');
+      expect(forecast).toBeDefined();
+      expect(forecast).toMatchObject({
+        name: 'forecast',
+        version: 'v1',
+        description: expect.any(String),
+        mimeType: 'application/json',
+      });
 
-    await mcp.resources.list(); // Initial call to establish connection
+      const historical = promptResources.find(r => r.name === 'historical');
+      expect(historical).toBeDefined();
+      expect(historical).toMatchObject({
+        name: 'historical',
+        version: 'v1',
+        description: expect.any(String),
+        mimeType: 'application/json',
+      });
+    });
 
-    const resourceListChangedPromise = new Promise<void>((resolve, reject) => {
-      mcp.resources.onListChanged(serverName, () => {
-        notificationReceived = true;
-        resolve();
+    it('should get a specific prompt from a server', async () => {
+      const {prompt, messages} = await mcp.prompts.get({serverName: 'weather', name: 'current'});
+      expect(prompt).toBeDefined();
+      expect(prompt).toMatchObject({
+        name: 'current',
+        version: 'v1',
+        description: expect.any(String),
+        mimeType: 'application/json',
       });
-      setTimeout(() => reject(new Error('Timeout waiting for resourceListChanged notification')), 4500);
+      expect(messages).toBeDefined();
+      const messageItem = messages[0];
+      let parsedText: any = {};
+      if (messageItem.content.text && typeof messageItem.content.text === 'string') {
+        try {
+          parsedText = JSON.parse(messageItem.content.text);
+        } catch {
+          // If parsing fails, parsedText remains an empty object
+          // console.error("Failed to parse resource content text:", _e);
+        }
+      }
+      expect(parsedText).toHaveProperty('location');
     });
 
-    // In a real scenario, something would trigger the server to send this.
-    // For the test, we rely on the interval in weather.ts or a direct call if available.
-    // Adding a small delay or an explicit trigger if the fixture supported it would be more robust.
-    // For now, we assume the interval in weather.ts will eventually fire it.
+    it('should receive prompt list changed notification from a specific server', async () => {
+      const serverName = 'weather';
+      let notificationReceived = false;
 
-    await expect(resourceListChangedPromise).resolves.toBeUndefined(); // Wait for the notification
+      await mcp.prompts.list();
 
-    expect(notificationReceived).toBe(true);
-  });
+      const promptListChangedPromise = new Promise<void>((resolve, reject) => {
+        mcp.prompts.onListChanged(serverName, () => {
+          notificationReceived = true;
+          resolve();
+        });
+        setTimeout(() => reject(new Error('Timeout waiting for promptListChanged notification')), 4500);
+      });
 
-  it('should handle errors when getting resources', async () => {
-    const errorClient = new MCPClient({
-      id: 'error-test-client',
-      servers: {
-        weather: {
-          url: new URL(`http://localhost:${weatherServerPort}/sse`),
-        },
-        nonexistentServer: {
-          command: 'nonexistent-command',
-          args: [],
-        },
-      },
+      await expect(promptListChangedPromise).resolves.toBeUndefined();
+
+      expect(notificationReceived).toBe(true);
     });
 
-    try {
-      const resources = await errorClient.resources.list();
+    it('should handle errors when getting prompts', async () => {
+      const errorClient = new MCPClient({
+        id: 'error-test-client',
+        servers: {
+          weather: {
+            url: new URL(`http://localhost:${weatherServerPort}/sse`),
+          },
+          nonexistentServer: {
+            command: 'nonexistent-command',
+            args: [],
+          },
+        },
+      });
 
-      expect(resources).toHaveProperty('weather');
-      expect(resources.weather).toBeDefined();
-      expect(resources.weather.length).toBeGreaterThan(0);
+      try {
+        const prompts = await errorClient.prompts.list();
 
-      expect(resources).not.toHaveProperty('nonexistentServer');
-    } finally {
-      await errorClient.disconnect();
-    }
-  });
+        expect(prompts).toHaveProperty('weather');
+        expect(prompts['weather']).toBeDefined();
+        expect(prompts['weather'].length).toBeGreaterThan(0);
 
-  it('should handle connection errors gracefully', async () => {
-    const badConfig = new MCPClient({
-      servers: {
-        badServer: {
-          command: 'nonexistent-command',
-          args: [],
-        },
-      },
+        expect(prompts).not.toHaveProperty('nonexistentServer');
+      } finally {
+        await errorClient.disconnect();
+      }
     });
-
-    await expect(badConfig.getTools()).rejects.toThrow();
-    await badConfig.disconnect();
-  });
+  })
 
   describe('Instance Management', () => {
     it('should allow multiple instances with different IDs', async () => {
@@ -479,6 +577,20 @@ describe('MCPClient', () => {
       await expect(mixedConfig.getTools()).rejects.toThrow(/Request timed out/);
       await mixedConfig.disconnect();
     });
+
+    it('should handle connection errors gracefully', async () => {
+      const badConfig = new MCPClient({
+        servers: {
+          badServer: {
+            command: 'nonexistent-command',
+            args: [],
+          },
+        },
+      });
+
+      await expect(badConfig.getTools()).rejects.toThrow();
+      await badConfig.disconnect();
+    });
   });
 
   describe('Schema Handling', () => {

package/src/client/configuration.ts

@@ -1,6 +1,6 @@
 import { MastraBase } from '@mastra/core/base';
 import { DEFAULT_REQUEST_TIMEOUT_MSEC } from '@modelcontextprotocol/sdk/shared/protocol.js';
-import type { Resource, ResourceTemplate } from '@modelcontextprotocol/sdk/types.js';
+import type { Prompt, Resource, ResourceTemplate } from '@modelcontextprotocol/sdk/types.js';
 import equal from 'fast-deep-equal';
 import { v5 as uuidv5 } from 'uuid';
 import { InternalMastraMCPClient } from './client';
@@ -114,6 +114,32 @@ To fix this you have three different options:
     };
   }
 
+  public get prompts() {
+    this.addToInstanceCache();
+    return {
+      list: async (): Promise<Record<string, Prompt[]>> => {
+        const allPrompts: Record<string, Prompt[]> = {};
+        for (const serverName of Object.keys(this.serverConfigs)) {
+          try {
+            const internalClient = await this.getConnectedClientForServer(serverName);
+            allPrompts[serverName] = await internalClient.prompts.list();
+          } catch (error) {
+            this.logger.error(`Failed to list prompts from server ${serverName}`, { error });
+          }
+        }
+        return allPrompts;
+      },
+      get: async ({serverName, name, args, version}: {serverName: string, name: string, args?: Record<string, any>, version?: string}) => {
+        const internalClient = await this.getConnectedClientForServer(serverName);
+        return internalClient.prompts.get({name, args, version});
+      },
+      onListChanged: async (serverName: string, handler: () => void) => {
+        const internalClient = await this.getConnectedClientForServer(serverName);
+        return internalClient.prompts.onListChanged(handler);
+      },
+    };
+  }
+
   private addToInstanceCache() {
     if (!mcpClientInstances.has(this.id)) {
       mcpClientInstances.set(this.id, this);

package/src/client/index.ts

@@ -0,0 +1,3 @@
+export type { LoggingLevel, LogMessage, LogHandler, MastraMCPServerDefinition } from './client';
+export { MastraMCPClient } from './client';
+export * from './configuration';