@mastra/mcp 0.4.3 → 0.5.0-alpha.1

package/eslint.config.js

@@ -3,4 +3,9 @@ import { createConfig } from '@internal/lint/eslint';
 const config = await createConfig();
 
 /** @type {import("eslint").Linter.Config[]} */
-export default [...config];
+export default [
+  ...config,
+  {
+    ignores: ['**/integration-tests/**'],
+  },
+];

package/integration-tests/node_modules/.bin/tsc

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/home/runner/work/mastra/mastra/node_modules/.pnpm/typescript@5.8.3/node_modules/typescript/bin/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/typescript@5.8.3/node_modules/typescript/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/typescript@5.8.3/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/home/runner/work/mastra/mastra/node_modules/.pnpm/typescript@5.8.3/node_modules/typescript/bin/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/typescript@5.8.3/node_modules/typescript/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/typescript@5.8.3/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../typescript/bin/tsc" "$@"
+else
+  exec node  "$basedir/../typescript/bin/tsc" "$@"
+fi

package/integration-tests/node_modules/.bin/tsserver

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/home/runner/work/mastra/mastra/node_modules/.pnpm/typescript@5.8.3/node_modules/typescript/bin/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/typescript@5.8.3/node_modules/typescript/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/typescript@5.8.3/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/home/runner/work/mastra/mastra/node_modules/.pnpm/typescript@5.8.3/node_modules/typescript/bin/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/typescript@5.8.3/node_modules/typescript/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/typescript@5.8.3/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../typescript/bin/tsserver" "$@"
+else
+  exec node  "$basedir/../typescript/bin/tsserver" "$@"
+fi

package/integration-tests/node_modules/.bin/vitest

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/home/runner/work/mastra/mastra/node_modules/.pnpm/vitest@1.6.1_@edge-runtime+vm@3.2.0_@types+node@20.17.32_jsdom@26.0.0_bufferutil@4.0.9__b7b40f6481a5fb1015de024b8d25deb4/node_modules/vitest/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/vitest@1.6.1_@edge-runtime+vm@3.2.0_@types+node@20.17.32_jsdom@26.0.0_bufferutil@4.0.9__b7b40f6481a5fb1015de024b8d25deb4/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/home/runner/work/mastra/mastra/node_modules/.pnpm/vitest@1.6.1_@edge-runtime+vm@3.2.0_@types+node@20.17.32_jsdom@26.0.0_bufferutil@4.0.9__b7b40f6481a5fb1015de024b8d25deb4/node_modules/vitest/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/vitest@1.6.1_@edge-runtime+vm@3.2.0_@types+node@20.17.32_jsdom@26.0.0_bufferutil@4.0.9__b7b40f6481a5fb1015de024b8d25deb4/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../vitest/vitest.mjs" "$@"
+else
+  exec node  "$basedir/../vitest/vitest.mjs" "$@"
+fi

package/integration-tests/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "mcp-server-integration-tests",
+  "private": true,
+  "version": "0.1.0",
+  "scripts": {
+    "test:mcp": "vitest run ./src/server.test.ts",
+    "dev": "mastra dev"
+  },
+  "dependencies": {
+    "@ai-sdk/openai": "^1.3.21",
+    "@ai-sdk/react": "^1.2.11",
+    "@mastra/client-js": "workspace:*",
+    "@mastra/core": "workspace:*",
+    "@mastra/mcp": "workspace:*",
+    "dotenv": "^16.5.0",
+    "zod": "^3.24.3"
+  },
+  "devDependencies": {
+    "@testing-library/react": "^16.2.0",
+    "@types/node": "^20.17.27",
+    "mastra": "workspace:*",
+    "typescript": "^5.8.2",
+    "vitest": "^1.6.1"
+  }
+}

package/integration-tests/src/mastra/agents/weather.ts

@@ -0,0 +1,20 @@
+import { openai } from '@ai-sdk/openai';
+import { createTool } from '@mastra/core';
+import { Agent } from '@mastra/core/agent';
+import { z } from 'zod';
+import { weatherTool } from '../tools/weather';
+
+export const weatherAgent = new Agent({
+  name: 'test',
+  instructions:
+    'You are a weather agent. When asked about weather in any city, use the get_weather tool with the city name as the postal code. When asked for clipboard contents you also get that.',
+  model: openai('gpt-4o'),
+  tools: {
+    get_weather: weatherTool,
+    clipboard: createTool({
+      id: 'clipboard',
+      description: 'Returns the contents of the users clipboard',
+      inputSchema: z.object({}),
+    }),
+  },
+});

package/integration-tests/src/mastra/index.ts

@@ -0,0 +1,12 @@
+import { Mastra } from '@mastra/core';
+import { weatherAgent } from './agents/weather';
+import { myMcpServer } from './mcp';
+
+export const mastra = new Mastra({
+  agents: {
+    test: weatherAgent,
+  },
+  mcpServers: {
+    myMcpServer,
+  },
+});

package/integration-tests/src/mastra/mcp/index.ts

@@ -0,0 +1,46 @@
+import { createTool } from '@mastra/core/tools';
+import { MCPServer } from '@mastra/mcp';
+import { z } from 'zod';
+
+export const myMcpServer = new MCPServer({
+  name: 'My Calculation & Data MCP Server',
+  version: '1.0.0',
+  tools: {
+    calculator: createTool({
+      id: 'calculator',
+      description: 'Performs basic arithmetic operations (add, subtract).',
+      inputSchema: z.object({
+        num1: z.number().describe('The first number.'),
+        num2: z.number().describe('The second number.'),
+        operation: z.enum(['add', 'subtract']).describe('The operation to perform.'),
+      }),
+      execute: async ({ context }) => {
+        const { num1, num2, operation } = context;
+        if (operation === 'add') {
+          return num1 + num2;
+        }
+        if (operation === 'subtract') {
+          return num1 - num2;
+        }
+        throw new Error('Invalid operation');
+      },
+    }),
+    fetchWeather: createTool({
+      id: 'fetchWeather',
+      description: 'Fetches a (simulated) weather forecast for a given city.',
+      inputSchema: z.object({
+        city: z.string().describe('The city to get weather for, e.g., London, Paris.'),
+      }),
+      execute: async ({ context }) => {
+        const { city } = context;
+        const temperatures = {
+          london: '15°C',
+          paris: '18°C',
+          tokyo: '22°C',
+        };
+        const temp = temperatures[city.toLowerCase() as keyof typeof temperatures] || '20°C';
+        return `The weather in ${city} is ${temp} and sunny.`;
+      },
+    }),
+  },
+});

package/integration-tests/src/mastra/tools/weather.ts

@@ -0,0 +1,13 @@
+import { createTool } from '@mastra/core/tools';
+import { z } from 'zod';
+
+export const weatherTool = createTool({
+  id: 'get_weather',
+  description: 'Get the weather for a given location',
+  inputSchema: z.object({
+    postalCode: z.string().describe('The location to get the weather for'),
+  }),
+  execute: async ({ context: { postalCode } }) => {
+    return `The weather in ${postalCode} is sunny. It is currently 70 degrees and feels like 65 degrees.`;
+  },
+});

package/integration-tests/src/server.test.ts

@@ -0,0 +1,149 @@
+import { spawn } from 'node:child_process';
+import { createServer } from 'node:http';
+import path from 'path';
+import { MCPClient } from '@mastra/mcp';
+import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
+
+vi.setConfig({ testTimeout: 20000, hookTimeout: 20000 });
+
+// Helper to find an available port
+async function getAvailablePort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.listen(0, () => {
+      const { port } = server.address() as { port: number };
+      server.close(() => resolve(port));
+    });
+    server.on('error', reject);
+  });
+}
+
+describe('MCPServer through Mastra HTTP Integration (Subprocess)', () => {
+  let mastraServer: ReturnType<typeof spawn>;
+  let port: number;
+  const mcpServerId = 'myMcpServer';
+  const testToolId = 'calculator';
+  let client: MCPClient;
+
+  beforeAll(async () => {
+    port = await getAvailablePort();
+
+    mastraServer = spawn(
+      'pnpm',
+      [
+        path.resolve(import.meta.dirname, `..`, `..`, `..`, `cli`, `dist`, `index.js`),
+        'dev',
+        '--port',
+        port.toString(),
+      ],
+      {
+        stdio: 'pipe',
+        detached: true, // Run in a new process group so we can kill it and children
+      },
+    );
+
+    // Wait for server to be ready
+    await new Promise<void>((resolve, reject) => {
+      let output = '';
+      mastraServer.stdout?.on('data', data => {
+        output += data.toString();
+        console.log(output);
+        if (output.includes('http://localhost:')) {
+          resolve();
+        }
+      });
+      mastraServer.stderr?.on('data', data => {
+        console.error('Mastra server error:', data.toString());
+      });
+
+      setTimeout(() => reject(new Error('Mastra server failed to start')), 10000);
+    });
+
+    client = new MCPClient({
+      servers: {
+        [mcpServerId]: {
+          url: new URL(`http://localhost:${port}/api/servers/${mcpServerId}/mcp`),
+        },
+      },
+    });
+  });
+
+  afterAll(() => {
+    // Kill the server and its process group
+    if (mastraServer?.pid) {
+      try {
+        process.kill(-mastraServer.pid, 'SIGTERM');
+      } catch (e) {
+        console.error('Failed to kill Mastra server:', e);
+      }
+    }
+  });
+
+  it('should allow an HTTP client to call a tool via Mastra MCP endpoint (Subprocess)', async () => {
+    const toolCallPayload = {
+      jsonrpc: '2.0',
+      id: `test-${Date.now()}`,
+      method: 'CallTool',
+      params: {
+        name: testToolId,
+        args: { num1: 10, num2: 5, operation: 'add' },
+      },
+    };
+
+    const tools = await client.getTools();
+    console.log('Tools:', tools);
+
+    const tool = tools['myMcpServer_calculator'];
+    console.log('Tool:', tool);
+
+    const result = await tool.execute({ context: toolCallPayload.params.args });
+    console.log('Result:', result);
+
+    expect(result).toBeDefined();
+    expect(result.isError).toBe(false);
+    expect(result.content).toBeInstanceOf(Array);
+    expect(result.content.length).toBeGreaterThan(0);
+
+    const toolOutput = result.content[0];
+    expect(toolOutput.type).toBe('text');
+
+    const expectedToolResult = 15;
+    expect(JSON.parse(toolOutput.text)).toEqual(expectedToolResult);
+  }, 25000);
+
+  it('should allow a client to call a tool via Mastra MCP SSE endpoints (Subprocess)', async () => {
+    const sseUrl = new URL(`http://localhost:${port}/api/servers/${mcpServerId}/sse`);
+
+    // Configure MCPClient for SSE transport
+    const sseClient = new MCPClient({
+      servers: {
+        [mcpServerId]: {
+          url: sseUrl, // URL for establishing SSE connection
+        },
+      },
+    });
+
+    const toolCallPayloadParams = { num1: 10, num2: 5, operation: 'add' };
+
+    // Get tools (this will connect the client internally if not already connected)
+    const tools = await sseClient.getTools();
+
+    const toolName = `${mcpServerId}_${testToolId}`;
+    const tool = tools[toolName];
+    expect(tool, `Tool '${toolName}' should be available via SSE client`).toBeDefined();
+
+    // Execute the tool
+    const result = await tool.execute({ context: toolCallPayloadParams });
+
+    expect(result).toBeDefined();
+    expect(result.isError).toBe(false);
+    expect(result.content).toBeInstanceOf(Array);
+    expect(result.content.length).toBeGreaterThan(0);
+
+    const toolOutput = result.content[0];
+    expect(toolOutput.type).toBe('text');
+
+    const expectedToolResult = 15; // 10 + 5
+    expect(JSON.parse(toolOutput.text)).toEqual(expectedToolResult);
+  }, 25000);
+});

package/integration-tests/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
+}

package/integration-tests/vitest.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    testTimeout: 60000,
+    hookTimeout: 30000,
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+    },
+  },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/mcp",
-  "version": "0.4.3",
+  "version": "0.5.0-alpha.1",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -26,15 +26,18 @@
     "date-fns": "^4.1.0",
     "exit-hook": "^4.0.0",
     "fast-deep-equal": "^3.1.3",
+    "json-schema-to-zod": "^2.6.0",
     "uuid": "^11.1.0",
-    "@mastra/core": "^0.9.3"
+    "@mastra/core": "^0.9.4-alpha.1"
+  },
+  "peerDependencies": {
+    "zod": "^3.0.0"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^1.1.15",
     "@microsoft/api-extractor": "^7.52.5",
     "@types/node": "^20.17.27",
     "eslint": "^9.23.0",
-    "json-schema-to-zod": "^2.6.0",
     "tsup": "^8.4.0",
     "tsx": "^4.19.3",
     "typescript": "^5.8.2",
@@ -46,7 +49,8 @@
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",
     "build:watch": "pnpm build --watch",
-    "test": "vitest run",
+    "test:integration": "cd integration-tests && pnpm test:mcp",
+    "test": "pnpm test:integration && vitest run",
     "lint": "eslint ."
   }
 }

package/src/__fixtures__/weather.ts

@@ -2,7 +2,12 @@ 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 } from '@modelcontextprotocol/sdk/types.js';
+import { 
+  CallToolRequestSchema, 
+  ListToolsRequestSchema, 
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema
+} from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 
@@ -27,6 +32,7 @@ const server = new Server(
   {
     capabilities: {
       tools: {},
+      resources: {}
     },
   },
 );
@@ -86,6 +92,92 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
   ],
 }));
 
+// Resources implementation
+const weatherResources = [
+  {
+    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'
+  }
+];
+
+// 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
+          })
+        }
+      ]
+    };
+  }
+  
+  throw new Error(`Resource not found: ${uri}`);
+});
+
 server.setRequestHandler(CallToolRequestSchema, async request => {
   try {
     switch (request.params.name) {

package/src/configuration.test.ts

@@ -94,6 +94,70 @@ describe('MCPClient', () => {
     expect(connectedToolsets.weather).toHaveProperty('getWeather');
   });
 
+  it('should get resources from connected MCP servers', async () => {
+    const resources = await mcp.getResources();
+
+    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',
+    });
+  });
+
+  it('should handle errors when getting resources', async () => {
+    const errorClient = new MCPClient({
+      id: 'error-test-client',
+      servers: {
+        weather: {
+          url: new URL('http://localhost:60808/sse'),
+        },
+        nonexistentServer: {
+          command: 'nonexistent-command',
+          args: [],
+        },
+      },
+    });
+
+    try {
+      const resources = await errorClient.getResources();
+
+      expect(resources).toHaveProperty('weather');
+      expect(resources.weather).toBeDefined();
+      expect(resources.weather.length).toBeGreaterThan(0);
+
+      expect(resources).not.toHaveProperty('nonexistentServer');
+    } finally {
+      await errorClient.disconnect();
+    }
+  });
+
   it('should handle connection errors gracefully', async () => {
     const badConfig = new MCPClient({
       servers: {

package/src/configuration.ts

@@ -1,5 +1,6 @@
 import { MastraBase } from '@mastra/core/base';
 import { DEFAULT_REQUEST_TIMEOUT_MSEC } from '@modelcontextprotocol/sdk/shared/protocol.js';
+import type { Resource } from '@modelcontextprotocol/sdk/types.js';
 import equal from 'fast-deep-equal';
 import { v5 as uuidv5 } from 'uuid';
 import { InternalMastraMCPClient } from './client';
@@ -123,6 +124,23 @@ To fix this you have three different options:
     return connectedToolsets;
   }
 
+  /**
+   * Get all resources from connected MCP servers
+   * @returns A record of server names to their resources
+   */
+  public async getResources() {
+    this.addToInstanceCache();
+    const connectedResources: Record<string, Resource[]> = {};
+
+    await this.eachClientResources(async ({ serverName, resources }) => {
+      if (resources && Array.isArray(resources)) {
+        connectedResources[serverName] = resources;
+      }
+    });
+
+    return connectedResources;
+  }
+
   /**
    * Get the current session IDs for all connected MCP clients using the Streamable HTTP transport.
    * Returns an object mapping server names to their session IDs.
@@ -186,7 +204,7 @@ To fix this you have three different options:
   }
 
   private async eachClientTools(
-    cb: (input: {
+    cb: (args: {
       serverName: string;
       tools: Record<string, any>; // <- any because we don't have proper tool schemas
       client: InstanceType<typeof InternalMastraMCPClient>;
@@ -200,6 +218,35 @@ To fix this you have three different options:
       }),
     );
   }
+
+  /**
+   * Helper method to iterate through each connected MCP client and retrieve resources
+   * @param cb Callback function to process resources from each server
+   */
+  private async eachClientResources(
+    cb: (args: {
+      serverName: string;
+      resources: Resource[];
+      client: InstanceType<typeof InternalMastraMCPClient>;
+    }) => Promise<void>,
+  ) {
+    await Promise.all(
+      Object.entries(this.serverConfigs).map(async ([serverName, serverConfig]) => {
+        try {
+          const client = await this.getConnectedClient(serverName, serverConfig);
+          const response = await client.resources();
+          // Ensure response has the expected structure
+          if (response && 'resources' in response && Array.isArray(response.resources)) {
+            await cb({ serverName, resources: response.resources, client });
+          }
+        } catch (e) {
+          this.logger.error(`Error getting resources from server ${serverName}`, {
+            error: e instanceof Error ? e.message : String(e),
+          });
+        }
+      }),
+    );
+  }
 }
 
 /**