@mastra/mcp 0.10.0 → 0.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/mcp",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -37,6 +37,7 @@
   "devDependencies": {
     "@ai-sdk/anthropic": "^1.1.15",
     "@ai-sdk/openai": "^1.3.22",
+    "ai": "4.3.16",
     "@hono/node-server": "^1.13.8",
     "@mendable/firecrawl-js": "^1.24.0",
     "@microsoft/api-extractor": "^7.52.5",
@@ -49,8 +50,8 @@
     "vitest": "^3.1.2",
     "zod": "^3.24.3",
     "zod-to-json-schema": "^3.24.5",
-    "@internal/lint": "0.0.6",
-    "@mastra/core": "0.10.0"
+    "@internal/lint": "0.0.7",
+    "@mastra/core": "0.10.1"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",

package/src/__fixtures__/fire-crawl-complex-schema.ts

@@ -4,7 +4,7 @@ import type { ToolsInput } from '@mastra/core/agent';
 import FirecrawlApp from '@mendable/firecrawl-js';
 import type { ScrapeParams, MapParams, CrawlParams, FirecrawlDocument } from '@mendable/firecrawl-js';
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { MCPServer } from '../server';
+import { MCPServer } from '../server/server';
 
 // Tool definitions
 const SCRAPE_TOOL: Tool = {

package/src/__fixtures__/server-weather.ts

@@ -1,4 +1,4 @@
-import { MCPServer } from '../server';
+import { MCPServer } from '../server/server';
 import { weatherTool } from './tools';
 
 const server = new MCPServer({

package/src/__fixtures__/weather.ts

@@ -1,15 +1,10 @@
 import type { IncomingMessage, ServerResponse } from 'http';
 import { createServer } from 'http';
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  ListResourcesRequestSchema,
-  ReadResourceRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js';
+import { createTool } from '@mastra/core';
+import type { Resource, ResourceTemplate } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
-import { zodToJsonSchema } from 'zod-to-json-schema';
+import { MCPServer } from '../server/server';
+import type { MCPServerResources, MCPServerResourceContent } from '../server/server';
 
 const getWeather = async (location: string) => {
   // Return mock data for testing
@@ -24,29 +19,20 @@ const getWeather = async (location: string) => {
   };
 };
 
-const server = new Server(
-  {
-    name: 'Weather Server',
-    version: '1.0.0',
-  },
-  {
-    capabilities: {
-      tools: {},
-      resources: {},
-    },
-  },
-);
+const serverId = 'weather-server-fixture';
+console.log(`[${serverId}] Initializing`);
 
 const weatherInputSchema = z.object({
   location: z.string().describe('City name'),
 });
 
-const weatherTool = {
-  name: 'getWeather',
+const weatherToolDefinition = createTool({
+  id: 'getWeather',
   description: 'Get current weather for a location',
-  execute: async (args: z.infer<typeof weatherInputSchema>) => {
+  inputSchema: weatherInputSchema,
+  execute: async ({ context }) => {
     try {
-      const weatherData = await getWeather(args.location);
+      const weatherData = await getWeather(context.location);
       return {
         content: [
           {
@@ -57,43 +43,21 @@ const weatherTool = {
         isError: false,
       };
     } catch (error) {
-      if (error instanceof Error) {
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Weather fetch failed: ${error.message}`,
-            },
-          ],
-          isError: true,
-        };
-      }
+      const message = error instanceof Error ? error.message : String(error);
       return {
         content: [
           {
             type: 'text',
-            text: 'An unknown error occurred.',
+            text: `Weather fetch failed: ${message}`,
           },
         ],
         isError: true,
       };
     }
   },
-};
-
-// Set up request handlers
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: [
-    {
-      name: weatherTool.name,
-      description: weatherTool.description,
-      inputSchema: zodToJsonSchema(weatherInputSchema),
-    },
-  ],
-}));
+});
 
-// Resources implementation
-const weatherResources = [
+const weatherResourceDefinitions: Resource[] = [
   {
     uri: 'weather://current',
     name: 'Current Weather Data',
@@ -114,164 +78,132 @@ const weatherResources = [
   },
 ];
 
-// List available resources
-server.setRequestHandler(ListResourcesRequestSchema, async () => ({
-  resources: weatherResources,
-}));
-
-// Read resource contents
-server.setRequestHandler(ReadResourceRequestSchema, async request => {
-  const uri = request.params.uri;
-
-  if (uri === 'weather://current') {
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: 'application/json',
-          text: JSON.stringify({
-            location: 'San Francisco',
-            temperature: 18,
-            conditions: 'Partly Cloudy',
-            humidity: 65,
-            windSpeed: 12,
-            updated: new Date().toISOString(),
-          }),
-        },
-      ],
-    };
-  } else if (uri === 'weather://forecast') {
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: 'application/json',
-          text: JSON.stringify([
-            { day: 1, high: 19, low: 12, conditions: 'Sunny' },
-            { day: 2, high: 22, low: 14, conditions: 'Clear' },
-            { day: 3, high: 20, low: 13, conditions: 'Partly Cloudy' },
-            { day: 4, high: 18, low: 11, conditions: 'Rain' },
-            { day: 5, high: 17, low: 10, conditions: 'Showers' },
-          ]),
-        },
-      ],
-    };
-  } else if (uri === 'weather://historical') {
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: 'application/json',
-          text: JSON.stringify({
-            averageHigh: 20,
-            averageLow: 12,
-            rainDays: 8,
-            sunnyDays: 18,
-            recordHigh: 28,
-            recordLow: 7,
-          }),
-        },
-      ],
-    };
-  }
+const weatherResourceTemplatesDefinitions: ResourceTemplate[] = [
+  {
+    uriTemplate: 'weather://custom/{city}/{days}',
+    name: 'Custom Weather Forecast',
+    description: 'Generates a custom weather forecast for a city and number of days.',
+    mimeType: 'application/json',
+  },
+];
 
-  throw new Error(`Resource not found: ${uri}`);
-});
+const weatherResourceContents: Record<string, MCPServerResourceContent> = {
+  'weather://current': {
+    text: JSON.stringify({
+      location: 'San Francisco',
+      temperature: 18,
+      conditions: 'Partly Cloudy',
+      humidity: 65,
+      windSpeed: 12,
+      updated: new Date().toISOString(),
+    }),
+  },
+  'weather://forecast': {
+    text: JSON.stringify([
+      { day: 1, high: 19, low: 12, conditions: 'Sunny' },
+      { day: 2, high: 22, low: 14, conditions: 'Clear' },
+      { day: 3, high: 20, low: 13, conditions: 'Partly Cloudy' },
+      { day: 4, high: 18, low: 11, conditions: 'Rain' },
+      { day: 5, high: 17, low: 10, conditions: 'Showers' },
+    ]),
+  },
+  'weather://historical': {
+    text: JSON.stringify({
+      averageHigh: 20,
+      averageLow: 12,
+      rainDays: 8,
+      sunnyDays: 18,
+      recordHigh: 28,
+      recordLow: 7,
+    }),
+  },
+};
 
-server.setRequestHandler(CallToolRequestSchema, async request => {
-  try {
-    switch (request.params.name) {
-      case 'getWeather': {
-        const args = weatherInputSchema.parse(request.params.arguments);
-        return await weatherTool.execute(args);
-      }
-      default:
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Unknown tool: ${request.params.name}`,
-            },
-          ],
-          isError: true,
-        };
+const mcpServerResources: MCPServerResources = {
+  listResources: async () => weatherResourceDefinitions,
+  getResourceContent: async ({ uri }: { uri: string }) => {
+    if (weatherResourceContents[uri]) {
+      return weatherResourceContents[uri];
     }
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `Invalid arguments: ${error.errors.map(e => `${e.path.join('.')}: ${e.message}`).join(', ')}`,
-          },
-        ],
-        isError: true,
-      };
-    }
-    return {
-      content: [
-        {
-          type: 'text',
-          text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-        },
-      ],
-      isError: true,
-    };
-  }
-});
+    throw new Error(`Mock resource content not found for ${uri}`);
+  },
+  resourceTemplates: async () => weatherResourceTemplatesDefinitions,
+};
 
-// Start the server
-let transport: SSEServerTransport | undefined;
+const mcpServer = new MCPServer({
+  name: serverId,
+  version: '1.0.0',
+  tools: {
+    getWeather: weatherToolDefinition,
+  },
+  resources: mcpServerResources,
+});
 
 const httpServer = createServer(async (req: IncomingMessage, res: ServerResponse) => {
   const url = new URL(req.url || '', `http://${req.headers.host}`);
+  const connectionLogPrefix = `[${serverId}] REQ: ${req.method} ${url.pathname}`;
+  console.log(connectionLogPrefix);
+
+  await mcpServer.startSSE({
+    url,
+    ssePath: '/sse',
+    messagePath: '/message',
+    req,
+    res,
+  });
+});
 
-  if (url.pathname === '/sse') {
-    console.log('Received SSE connection');
-    transport = new SSEServerTransport('/message', res);
-    await server.connect(transport);
+const PORT = process.env.WEATHER_SERVER_PORT || 60808;
+console.log(`[${serverId}] Starting HTTP server on port ${PORT}`);
+httpServer.listen(PORT, () => {
+  console.log(`[${serverId}] Weather server is running on SSE at http://localhost:${PORT}`);
+});
 
-    server.onclose = async () => {
-      await server.close();
-      transport = undefined;
-    };
+// --- Interval-based Notifications ---
+const NOTIFICATION_INTERVAL_MS = 1500;
+let resourceUpdateCounter = 0;
+
+const notificationInterval = setInterval(async () => {
+  // Simulate resource update for weather://current
+  resourceUpdateCounter++;
+  const newCurrentWeatherText = JSON.stringify({
+    location: 'San Francisco',
+    temperature: 18 + (resourceUpdateCounter % 5), // Vary temperature slightly
+    conditions: resourceUpdateCounter % 2 === 0 ? 'Sunny' : 'Partly Cloudy',
+    humidity: 65 + (resourceUpdateCounter % 3),
+    windSpeed: 12 + (resourceUpdateCounter % 4),
+    updated: new Date().toISOString(),
+  });
+  weatherResourceContents['weather://current'] = { text: newCurrentWeatherText };
 
-    // 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 updatePrefix = `[${serverId}] IntervalUpdate`;
+  try {
+    await mcpServer.resources.notifyUpdated({ uri: 'weather://current' });
+  } catch (e: any) {
+    console.error(`${updatePrefix} - Error sending resourceUpdated for weather://current via MCPServer: ${e.message}`);
   }
-});
 
-const PORT = process.env.PORT || 60808;
-httpServer.listen(PORT, () => {
-  console.log(`Weather server is running on SSE at http://localhost:${PORT}`);
-});
+  // Simulate resource list changed (less frequently, e.g., every 3rd interval)
+  if (resourceUpdateCounter % 3 === 0) {
+    const listChangePrefix = `[${serverId}] IntervalListChange`;
+    try {
+      await mcpServer.resources.notifyListChanged();
+    } catch (e: any) {
+      console.error(`${listChangePrefix} - Error sending resourceListChanged via MCPServer: ${e.message}`);
+    }
+  }
+}, NOTIFICATION_INTERVAL_MS);
+// --- End Interval-based Notifications ---
 
 // Handle graceful shutdown
 process.on('SIGINT', async () => {
   console.log('Shutting down weather server...');
-  if (transport) {
-    await server.close();
-    transport = undefined;
-  }
-  // Close the HTTP server
+  clearInterval(notificationInterval); // Clear the interval
+  await mcpServer.close();
   httpServer.close(() => {
     console.log('Weather server shut down complete');
     process.exit(0);
   });
 });
 
-export { server };
+export { mcpServer as server };

package/src/{client.test.ts → client/client.test.ts}

@@ -18,6 +18,7 @@ async function setupTestServer(withSessionManagement: boolean) {
       capabilities: {
         logging: {},
         tools: {},
+        resources: {},
       },
     },
   );
@@ -35,6 +36,17 @@ async function setupTestServer(withSessionManagement: boolean) {
     },
   );
 
+  mcpServer.resource('test-resource', 'resource://test', () => {
+    return {
+      contents: [
+        {
+          uri: 'resource://test',
+          text: 'Hello, world!',
+        },
+      ],
+    };
+  });
+
   const serverTransport = new StreamableHTTPServerTransport({
     sessionIdGenerator: withSessionManagement ? () => randomUUID() : undefined,
   });
@@ -94,6 +106,21 @@ describe('MastraMCPClient with Streamable HTTP', () => {
       const result = await tools.greet.execute({ context: { name: 'Stateless' } });
       expect(result).toEqual({ content: [{ type: 'text', text: 'Hello, Stateless!' }] });
     });
+
+    it('should list resources', async () => {
+      const resourcesResult = await client.listResources();
+      const resources = resourcesResult.resources;
+      expect(resources).toBeInstanceOf(Array);
+      const testResource = resources.find((r) => r.uri === 'resource://test');
+      expect(testResource).toBeDefined();
+      expect(testResource!.name).toBe('test-resource');
+      expect(testResource!.uri).toBe('resource://test');
+
+      const readResult = await client.readResource('resource://test');
+      expect(readResult.contents).toBeInstanceOf(Array);
+      expect(readResult.contents.length).toBe(1);
+      expect(readResult.contents[0].text).toBe('Hello, world!');
+    });
   });
 
   describe('Stateful Mode', () => {

package/src/{client.ts → client/client.ts}

@@ -10,14 +10,22 @@ import { getDefaultEnvironment, StdioClientTransport } from '@modelcontextprotoc
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import type { StreamableHTTPClientTransportOptions } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 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, LoggingLevel } from '@modelcontextprotocol/sdk/types.js';
-import { CallToolResultSchema, ListResourcesResultSchema } from '@modelcontextprotocol/sdk/types.js';
+import {
+  CallToolResultSchema,
+  ListResourcesResultSchema,
+  ReadResourceResultSchema,
+  ResourceListChangedNotificationSchema,
+  ResourceUpdatedNotificationSchema,
+  ListResourceTemplatesResultSchema,
+} 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 { ResourceClientActions } from './resourceActions';
 
 // Re-export MCP SDK LoggingLevel for convenience
 export type { LoggingLevel } from '@modelcontextprotocol/sdk/types.js';
@@ -110,6 +118,7 @@ export class InternalMastraMCPClient extends MastraBase {
   private serverConfig: MastraMCPServerDefinition;
   private transport?: Transport;
   private currentOperationContext: RuntimeContext | null = null;
+  public readonly resources: ResourceClientActions;
 
   constructor({
     name,
@@ -137,6 +146,8 @@ export class InternalMastraMCPClient extends MastraBase {
 
     // Set up log message capturing
     this.setupLogging();
+    
+    this.resources = new ResourceClientActions({ client: this, logger: this.logger });
   }
 
   /**
@@ -317,15 +328,57 @@ export class InternalMastraMCPClient 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']>> {
+  async listResources() {
     this.log('debug', `Requesting resources from MCP server`);
     return await this.client.request({ method: 'resources/list' }, ListResourcesResultSchema, {
       timeout: this.timeout,
     });
   }
 
+  async readResource(uri: string) {
+    this.log('debug', `Reading resource from MCP server: ${uri}`);
+    return await this.client.request({ method: 'resources/read', params: { uri } }, ReadResourceResultSchema, {
+      timeout: this.timeout,
+    });
+  }
+
+  async subscribeResource(uri: string) {
+    this.log('debug', `Subscribing to resource on MCP server: ${uri}`);
+    return await this.client.request({ method: 'resources/subscribe', params: { uri } }, z.object({}), {
+      timeout: this.timeout,
+    });
+  }
+
+  async unsubscribeResource(uri: string) {
+    this.log('debug', `Unsubscribing from resource on MCP server: ${uri}`);
+    return await this.client.request({ method: 'resources/unsubscribe', params: { uri } }, z.object({}), {
+      timeout: this.timeout,
+    });
+  }
+
+  async listResourceTemplates() {
+    this.log('debug', `Requesting resource templates from MCP server`);
+    return await this.client.request({ method: 'resources/templates/list' }, ListResourceTemplatesResultSchema, {
+      timeout: this.timeout,
+    });
+  }
+
+  setResourceUpdatedNotificationHandler(
+    handler: (params: z.infer<typeof ResourceUpdatedNotificationSchema>['params']) => void,
+  ): void {
+    this.log('debug', 'Setting resource updated notification handler');
+    this.client.setNotificationHandler(ResourceUpdatedNotificationSchema, notification => {
+      handler(notification.params);
+    });
+  }
+
+  setResourceListChangedNotificationHandler(handler: () => void): void {
+    this.log('debug', 'Setting resource list changed notification handler');
+    this.client.setNotificationHandler(ResourceListChangedNotificationSchema, () => {
+      handler();
+    });
+  }
+
   private convertInputSchema(
     inputSchema: Awaited<ReturnType<Client['listTools']>>['tools'][0]['inputSchema'] | JSONSchema,
   ): z.ZodType {