@mastra/mcp 0.11.3-alpha.1 → 0.11.3-alpha.2

package/src/__fixtures__/server-weather.ts

@@ -1,16 +0,0 @@
-import { MCPServer } from '../server/server';
-import { weatherTool } from './tools';
-
-const server = new MCPServer({
-  name: 'My MCP Server',
-  version: '1.0.0',
-  tools: {
-    weatherTool,
-  },
-});
-
-server.startStdio().catch(error => {
-  const errorMessage = 'Fatal error running server';
-  console.error(errorMessage, error);
-  process.exit(1);
-});

package/src/__fixtures__/stock-price.ts

@@ -1,128 +0,0 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { z } from 'zod';
-import { zodToJsonSchema } from 'zod-to-json-schema';
-
-const getStockPrice = async (symbol: string) => {
-  // Return mock data for testing
-  return {
-    symbol,
-    currentPrice: '150.00',
-  };
-};
-
-const server = new Server(
-  {
-    name: 'Stock Price Server',
-    version: '1.0.0',
-  },
-  {
-    capabilities: {
-      tools: {},
-    },
-  },
-);
-
-const stockInputSchema = z.object({
-  symbol: z.string().describe('Stock symbol'),
-});
-
-const stockTool = {
-  name: 'getStockPrice',
-  description: "Fetches the last day's closing stock price for a given symbol",
-  execute: async (args: z.infer<typeof stockInputSchema>) => {
-    try {
-      const priceData = await getStockPrice(args.symbol);
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify(priceData),
-          },
-        ],
-        isError: false,
-      };
-    } catch (error) {
-      if (error instanceof Error) {
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Stock price fetch failed: ${error.message}`,
-            },
-          ],
-          isError: true,
-        };
-      }
-      return {
-        content: [
-          {
-            type: 'text',
-            text: 'An unknown error occurred.',
-          },
-        ],
-        isError: true,
-      };
-    }
-  },
-};
-
-// Set up request handlers
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: [
-    {
-      name: stockTool.name,
-      description: stockTool.description,
-      inputSchema: zodToJsonSchema(stockInputSchema),
-    },
-  ],
-}));
-
-server.setRequestHandler(CallToolRequestSchema, async request => {
-  try {
-    switch (request.params.name) {
-      case 'getStockPrice': {
-        const args = stockInputSchema.parse(request.params.arguments);
-        return await stockTool.execute(args);
-      }
-      default:
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Unknown tool: ${request.params.name}`,
-            },
-          ],
-          isError: true,
-        };
-    }
-  } 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,
-    };
-  }
-});
-
-// Start the server
-const transport = new StdioServerTransport();
-await server.connect(transport);
-
-export { server };

package/src/__fixtures__/tools.ts

@@ -1,94 +0,0 @@
-import { createTool } from '@mastra/core/tools';
-import { z } from 'zod';
-
-interface GeocodingResponse {
-  results: {
-    latitude: number;
-    longitude: number;
-    name: string;
-  }[];
-}
-interface WeatherResponse {
-  current: {
-    time: string;
-    temperature_2m: number;
-    apparent_temperature: number;
-    relative_humidity_2m: number;
-    wind_speed_10m: number;
-    wind_gusts_10m: number;
-    weather_code: number;
-  };
-}
-
-export const weatherTool = createTool({
-  id: 'get-weather',
-  description: 'Get current weather for a location',
-  inputSchema: z.object({
-    location: z.string().describe('City name'),
-  }),
-  execute: async ({ context }) => {
-    console.log('weather tool', context);
-    return await getWeather(context.location);
-  },
-});
-
-const getWeather = async (location: string) => {
-  const geocodingUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(location)}&count=1`;
-  const geocodingResponse = await fetch(geocodingUrl);
-  const geocodingData = (await geocodingResponse.json()) as GeocodingResponse;
-
-  if (!geocodingData.results?.[0]) {
-    throw new Error(`Location '${location}' not found`);
-  }
-
-  const { latitude, longitude, name } = geocodingData.results[0];
-
-  const weatherUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current=temperature_2m,apparent_temperature,relative_humidity_2m,wind_speed_10m,wind_gusts_10m,weather_code`;
-
-  const response = await fetch(weatherUrl);
-  const data = (await response.json()) as WeatherResponse;
-
-  return {
-    temperature: data.current.temperature_2m,
-    feelsLike: data.current.apparent_temperature,
-    humidity: data.current.relative_humidity_2m,
-    windSpeed: data.current.wind_speed_10m,
-    windGust: data.current.wind_gusts_10m,
-    conditions: getWeatherCondition(data.current.weather_code),
-    location: name,
-  };
-};
-
-function getWeatherCondition(code: number): string {
-  const conditions: Record<number, string> = {
-    0: 'Clear sky',
-    1: 'Mainly clear',
-    2: 'Partly cloudy',
-    3: 'Overcast',
-    45: 'Foggy',
-    48: 'Depositing rime fog',
-    51: 'Light drizzle',
-    53: 'Moderate drizzle',
-    55: 'Dense drizzle',
-    56: 'Light freezing drizzle',
-    57: 'Dense freezing drizzle',
-    61: 'Slight rain',
-    63: 'Moderate rain',
-    65: 'Heavy rain',
-    66: 'Light freezing rain',
-    67: 'Heavy freezing rain',
-    71: 'Slight snow fall',
-    73: 'Moderate snow fall',
-    75: 'Heavy snow fall',
-    77: 'Snow grains',
-    80: 'Slight rain showers',
-    81: 'Moderate rain showers',
-    82: 'Violent rain showers',
-    85: 'Slight snow showers',
-    86: 'Heavy snow showers',
-    95: 'Thunderstorm',
-    96: 'Thunderstorm with slight hail',
-    99: 'Thunderstorm with heavy hail',
-  };
-  return conditions[code] || 'Unknown';
-}

package/src/__fixtures__/weather.ts

@@ -1,269 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'http';
-import { createServer } from 'http';
-import { createTool } from '@mastra/core/tools';
-import type { Prompt, PromptMessage, Resource, ResourceTemplate } from '@modelcontextprotocol/sdk/types.js';
-import { z } from 'zod';
-import { MCPServer } from '../server/server';
-import type { MCPServerResources, MCPServerResourceContent, MCPServerPrompts } from '../server/types';
-
-const getWeather = async (location: string) => {
-  // Return mock data for testing
-  return {
-    temperature: 20,
-    feelsLike: 18,
-    humidity: 65,
-    windSpeed: 10,
-    windGust: 15,
-    conditions: 'Clear sky',
-    location,
-  };
-};
-
-const serverId = 'weather-server-fixture';
-console.log(`[${serverId}] Initializing`);
-
-const weatherInputSchema = z.object({
-  location: z.string().describe('City name'),
-});
-
-const weatherToolDefinition = createTool({
-  id: 'getWeather',
-  description: 'Get current weather for a location',
-  inputSchema: weatherInputSchema,
-  execute: async ({ context }) => {
-    try {
-      const weatherData = await getWeather(context.location);
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify(weatherData),
-          },
-        ],
-        isError: false,
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `Weather fetch failed: ${message}`,
-          },
-        ],
-        isError: true,
-      };
-    }
-  },
-});
-
-const weatherResourceDefinitions: Resource[] = [
-  {
-    uri: 'weather://current',
-    name: 'Current Weather Data',
-    description: 'Real-time weather data for the current location',
-    mimeType: 'application/json',
-  },
-  {
-    uri: 'weather://forecast',
-    name: 'Weather Forecast',
-    description: '5-day weather forecast',
-    mimeType: 'application/json',
-  },
-  {
-    uri: 'weather://historical',
-    name: 'Historical Weather Data',
-    description: 'Weather data from the past 30 days',
-    mimeType: 'application/json',
-  },
-];
-
-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',
-  },
-];
-
-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,
-    }),
-  },
-};
-
-const weatherPrompts: Prompt[] = [
-  {
-    name: 'current',
-    version: 'v1',
-    description: 'Get current weather for a location',
-    mimeType: 'application/json',
-    content: JSON.stringify({
-      location: 'Current weather for San Francisco',
-    }),
-  },
-  {
-    name: 'forecast',
-    version: 'v1',
-    description: 'Get weather forecast for a location',
-    mimeType: 'application/json',
-    content: JSON.stringify({
-      location: 'Forecast for San Francisco',
-    }),
-  },
-  {
-    name: 'historical',
-    version: 'v1',
-    description: 'Get historical weather data for a location',
-    mimeType: 'application/json',
-    content: JSON.stringify({
-      location: 'Historical weather for San Francisco',
-    }),
-  },
-];
-
-const mcpServerResources: MCPServerResources = {
-  listResources: async () => weatherResourceDefinitions,
-  getResourceContent: async ({ uri }: { uri: string }) => {
-    if (weatherResourceContents[uri]) {
-      return weatherResourceContents[uri];
-    }
-    throw new Error(`Mock resource content not found for ${uri}`);
-  },
-  resourceTemplates: async () => weatherResourceTemplatesDefinitions,
-};
-
-const mcpServerPrompts: MCPServerPrompts = {
-  listPrompts: async () => weatherPrompts,
-  getPromptMessages: async ({ name }: { name: string }): Promise<PromptMessage[]> => {
-    const prompt = weatherPrompts.find(p => p.name === name);
-    if (!prompt) {
-      throw new Error(`Mock prompt not found for ${name}`);
-    }
-    return [
-      {
-        role: 'user',
-        content: {
-          type: 'text',
-          text: prompt.content as string,
-        },
-      },
-    ];
-  },
-};
-
-const mcpServer = new MCPServer({
-  name: serverId,
-  version: '1.0.0',
-  tools: {
-    getWeather: weatherToolDefinition,
-  },
-  resources: mcpServerResources,
-  prompts: mcpServerPrompts,
-});
-
-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,
-  });
-});
-
-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}`);
-});
-
-// --- 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 };
-
-  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}`);
-  }
-
-  // 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);
-
-const promptNotificationInterval = setInterval(async () => {
-  const listChangePrefix = `[${serverId}] IntervalListChange`;
-  try {
-    await mcpServer.prompts.notifyListChanged();
-  } catch (e: any) {
-    console.error(`${listChangePrefix} - Error sending promptListChanged via MCPServer: ${e.message}`);
-  }
-}, NOTIFICATION_INTERVAL_MS);
-// --- End Interval-based Notifications ---
-
-// Handle graceful shutdown
-process.on('SIGINT', async () => {
-  console.log('Shutting down weather server...');
-  clearInterval(notificationInterval); // Clear the interval
-  clearInterval(promptNotificationInterval); // Clear the interval
-  await mcpServer.close();
-  httpServer.close(() => {
-    console.log('Weather server shut down complete');
-    process.exit(0);
-  });
-});
-
-export { mcpServer as server };