@mastra/mcp 0.10.0 → 0.10.1

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

@@ -3,8 +3,9 @@ import path from 'path';
 import { openai } from '@ai-sdk/openai';
 import { Agent } from '@mastra/core/agent';
 import { RuntimeContext } from '@mastra/core/di';
+import type { ResourceTemplate } from '@modelcontextprotocol/sdk/types.js';
 import { describe, it, expect, beforeEach, afterEach, afterAll, beforeAll, vi } from 'vitest';
-import { allTools, mcpServerName } from './__fixtures__/fire-crawl-complex-schema';
+import { allTools, mcpServerName } from '../__fixtures__/fire-crawl-complex-schema';
 import type { LogHandler, LogMessage } from './client';
 import { MCPClient } from './configuration';
 
@@ -14,10 +15,14 @@ describe('MCPClient', () => {
   let mcp: MCPClient;
   let weatherProcess: ReturnType<typeof spawn>;
   let clients: MCPClient[] = [];
+  let weatherServerPort: number;
 
   beforeAll(async () => {
+    weatherServerPort = 60000 + Math.floor(Math.random() * 1000); // Generate a random port
     // Start the weather SSE server
-    weatherProcess = spawn('npx', ['-y', 'tsx', path.join(__dirname, '__fixtures__/weather.ts')]);
+    weatherProcess = spawn('npx', ['-y', 'tsx', path.join(__dirname, '..', '__fixtures__/weather.ts')], {
+      env: { ...process.env, WEATHER_SERVER_PORT: String(weatherServerPort) }, // Pass port as env var
+    });
 
     // Wait for SSE server to be ready
     let resolved = false;
@@ -42,17 +47,20 @@ describe('MCPClient', () => {
   });
 
   beforeEach(async () => {
+    // Give each MCPClient a unique ID to prevent re-initialization errors across tests
+    const testId = "testId"
     mcp = new MCPClient({
+      id: testId,
       servers: {
         stockPrice: {
           command: 'npx',
-          args: ['-y', 'tsx', path.join(__dirname, '__fixtures__/stock-price.ts')],
+          args: ['-y', 'tsx', path.join(__dirname, '..', '__fixtures__/stock-price.ts')],
           env: {
             FAKE_CREDS: 'test',
           },
         },
         weather: {
-          url: new URL('http://localhost:60808/sse'),
+          url: new URL(`http://localhost:${weatherServerPort}/sse`), // Use the dynamic port
         },
       },
     });
@@ -77,13 +85,13 @@ describe('MCPClient', () => {
     expect(mcp['serverConfigs']).toEqual({
       stockPrice: {
         command: 'npx',
-        args: ['-y', 'tsx', path.join(__dirname, '__fixtures__/stock-price.ts')],
+        args: ['-y', 'tsx', path.join(__dirname, '..', '__fixtures__/stock-price.ts')],
         env: {
           FAKE_CREDS: 'test',
         },
       },
       weather: {
-        url: new URL('http://localhost:60808/sse'),
+        url: new URL(`http://localhost:${weatherServerPort}/sse`),
       },
     });
   });
@@ -106,7 +114,7 @@ describe('MCPClient', () => {
   });
 
   it('should get resources from connected MCP servers', async () => {
-    const resources = await mcp.getResources();
+    const resources = await mcp.resources.list();
 
     expect(resources).toHaveProperty('weather');
     expect(resources.weather).toBeDefined();
@@ -142,12 +150,116 @@ describe('MCPClient', () => {
     });
   });
 
+  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 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 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 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);
+    });
+
+    await mcp.resources.subscribe(serverName, resourceUri); // Ensure subscription is active
+
+    await expect(resourceUpdatedPromise).resolves.toBeUndefined(); // Wait for the notification
+
+    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;
+
+    await mcp.resources.list(); // Initial call to establish connection
+
+    const resourceListChangedPromise = new Promise<void>((resolve, reject) => {
+      mcp.resources.onListChanged(serverName, () => {
+        notificationReceived = true;
+        resolve();
+      });
+      setTimeout(() => reject(new Error('Timeout waiting for resourceListChanged notification')), 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);
+  });
+
   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'),
+          url: new URL(`http://localhost:${weatherServerPort}/sse`),
         },
         nonexistentServer: {
           command: 'nonexistent-command',
@@ -157,7 +269,7 @@ describe('MCPClient', () => {
     });
 
     try {
-      const resources = await errorClient.getResources();
+      const resources = await errorClient.resources.list();
 
       expect(resources).toHaveProperty('weather');
       expect(resources.weather).toBeDefined();
@@ -190,7 +302,7 @@ describe('MCPClient', () => {
         servers: {
           stockPrice: {
             command: 'npx',
-            args: ['-y', 'tsx', path.join(__dirname, '__fixtures__/stock-price.ts')],
+            args: ['-y', 'tsx', path.join(__dirname, '..', '__fixtures__/stock-price.ts')],
             env: {
               FAKE_CREDS: 'test',
             },
@@ -209,13 +321,13 @@ describe('MCPClient', () => {
         servers: {
           stockPrice: {
             command: 'npx',
-            args: ['-y', 'tsx', path.join(__dirname, '__fixtures__/stock-price.ts')],
+            args: ['-y', 'tsx', path.join(__dirname, '..', '__fixtures__/stock-price.ts')],
             env: {
               FAKE_CREDS: 'test',
             },
           },
           weather: {
-            url: new URL('http://localhost:60808/sse'),
+            url: new URL(`http://localhost:${weatherServerPort}/sse`),
           },
         },
       });
@@ -229,7 +341,7 @@ describe('MCPClient', () => {
         servers: {
           stockPrice: {
             command: 'npx',
-            args: ['-y', 'tsx', path.join(__dirname, '__fixtures__/stock-price.ts')],
+            args: ['-y', 'tsx', path.join(__dirname, '..', '__fixtures__/stock-price.ts')],
             env: {
               FAKE_CREDS: 'test',
             },
@@ -243,7 +355,7 @@ describe('MCPClient', () => {
             servers: {
               stockPrice: {
                 command: 'npx',
-                args: ['-y', 'tsx', path.join(__dirname, '__fixtures__/stock-price.ts')],
+                args: ['-y', 'tsx', path.join(__dirname, '..', '__fixtures__/stock-price.ts')],
                 env: {
                   FAKE_CREDS: 'test',
                 },
@@ -381,7 +493,7 @@ describe('MCPClient', () => {
         servers: {
           'firecrawl-mcp': {
             command: 'npx',
-            args: ['-y', 'tsx', path.join(__dirname, '__fixtures__/fire-crawl-complex-schema.ts')],
+            args: ['-y', 'tsx', path.join(__dirname, '..', '__fixtures__/fire-crawl-complex-schema.ts')],
             logger: mockLogHandler,
           },
         },
@@ -390,7 +502,7 @@ describe('MCPClient', () => {
 
     afterEach(async () => {
       mockLogHandler.mockClear();
-      await complexClient?.disconnect().catch(() => {});
+      await complexClient?.disconnect().catch(() => { });
     });
 
     it('should process tools from firecrawl-mcp without crashing', async () => {
@@ -427,7 +539,7 @@ describe('MCPClient', () => {
         servers: {
           stockPrice: {
             command: 'npx',
-            args: ['tsx', path.join(__dirname, '__fixtures__/stock-price.ts')],
+            args: ['tsx', path.join(__dirname, '..', '__fixtures__/stock-price.ts')],
             env: { FAKE_CREDS: 'test' },
             logger: loggerFn,
           },
@@ -471,7 +583,7 @@ describe('MCPClient', () => {
         servers: {
           stockPriceServer: {
             command: 'npx',
-            args: ['tsx', path.join(__dirname, '__fixtures__/stock-price.ts')],
+            args: ['tsx', path.join(__dirname, '..', '__fixtures__/stock-price.ts')],
             env: { FAKE_CREDS: 'test' },
             logger: loggerFn,
           },
@@ -513,7 +625,7 @@ describe('MCPClient', () => {
         servers: {
           stockPriceServer: {
             command: 'npx',
-            args: ['tsx', path.join(__dirname, '__fixtures__/stock-price.ts')],
+            args: ['tsx', path.join(__dirname, '..', '__fixtures__/stock-price.ts')],
             env: { FAKE_CREDS: 'test' },
             logger: loggerFn,
           },
@@ -567,13 +679,13 @@ describe('MCPClient', () => {
         servers: {
           serverX: {
             command: 'npx',
-            args: ['tsx', path.join(__dirname, '__fixtures__/stock-price.ts')], // Re-use fixture, tool name will differ by server
+            args: ['tsx', path.join(__dirname, '..', '__fixtures__/stock-price.ts')], // Re-use fixture, tool name will differ by server
             logger: sharedLoggerFn,
             env: { FAKE_CREDS: 'serverX-creds' }, // Make env slightly different for clarity if needed
           },
           serverY: {
             command: 'npx',
-            args: ['tsx', path.join(__dirname, '__fixtures__/stock-price.ts')], // Re-use fixture
+            args: ['tsx', path.join(__dirname, '..', '__fixtures__/stock-price.ts')], // Re-use fixture
             logger: sharedLoggerFn,
             env: { FAKE_CREDS: 'serverY-creds' },
           },

package/src/{configuration.ts → 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 } from '@modelcontextprotocol/sdk/types.js';
+import type { Resource, ResourceTemplate } from '@modelcontextprotocol/sdk/types.js';
 import equal from 'fast-deep-equal';
 import { v5 as uuidv5 } from 'uuid';
 import { InternalMastraMCPClient } from './client';
@@ -35,6 +35,7 @@ export class MCPClient extends MastraBase {
         const existingInstance = mcpClientInstances.get(this.id);
         if (existingInstance) {
           void existingInstance.disconnect();
+          mcpClientInstances.delete(this.id);
         }
       }
     } else {
@@ -63,6 +64,56 @@ To fix this you have three different options:
     return this;
   }
 
+  public get resources() {
+    this.addToInstanceCache();
+    return {
+      list: async (): Promise<Record<string, Resource[]>> => {
+        const allResources: Record<string, Resource[]> = {};
+        for (const serverName of Object.keys(this.serverConfigs)) {
+          try {
+            const internalClient = await this.getConnectedClientForServer(serverName);
+            allResources[serverName] = await internalClient.resources.list();
+          } catch (error) {
+            this.logger.error(`Failed to list resources from server ${serverName}`, { error });
+          }
+        }
+        return allResources;
+      },
+      templates: async (): Promise<Record<string, ResourceTemplate[]>> => {
+        const allTemplates: Record<string, ResourceTemplate[]> = {};
+        for (const serverName of Object.keys(this.serverConfigs)) {
+          try {
+            const internalClient = await this.getConnectedClientForServer(serverName);
+            allTemplates[serverName] = await internalClient.resources.templates();
+          } catch (error) {
+            this.logger.error(`Failed to list resource templates from server ${serverName}`, { error });
+          }
+        }
+        return allTemplates;
+      },
+      read: async (serverName: string, uri: string) => {
+        const internalClient = await this.getConnectedClientForServer(serverName);
+        return internalClient.resources.read(uri);
+      },
+      subscribe: async (serverName: string, uri: string) => {
+        const internalClient = await this.getConnectedClientForServer(serverName);
+        return internalClient.resources.subscribe(uri);
+      },
+      unsubscribe: async (serverName: string, uri: string) => {
+        const internalClient = await this.getConnectedClientForServer(serverName);
+        return internalClient.resources.unsubscribe(uri);
+      },
+      onUpdated: async (serverName: string, handler: (params: { uri: string }) => void) => {
+        const internalClient = await this.getConnectedClientForServer(serverName);
+        return internalClient.resources.onUpdated(handler);
+      },
+      onListChanged: async (serverName: string, handler: () => void) => {
+        const internalClient = await this.getConnectedClientForServer(serverName);
+        return internalClient.resources.onListChanged(handler);
+      },
+    };
+  }
+
   private addToInstanceCache() {
     if (!mcpClientInstances.has(this.id)) {
       mcpClientInstances.set(this.id, this);
@@ -86,7 +137,7 @@ To fix this you have three different options:
     this.disconnectPromise = (async () => {
       try {
         mcpClientInstances.delete(this.id);
-
+        
         // Disconnect all clients in the cache
         await Promise.all(Array.from(this.mcpClientsById.values()).map(client => client.disconnect()));
         this.mcpClientsById.clear();
@@ -125,20 +176,10 @@ To fix this you have three different options:
   }
 
   /**
-   * Get all resources from connected MCP servers
-   * @returns A record of server names to their resources
+   * @deprecated all resource actions have been moved to the this.resources object. Use this.resources.list() instead.
    */
   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;
+    return this.resources.list();
   }
 
   /**
@@ -155,9 +196,7 @@ To fix this you have three different options:
     return sessionIds;
   }
 
-  private async getConnectedClient(name: string, config: MastraMCPServerDefinition) {
-    // Helps to prevent race condition.
-    // If we want to call connect() we need to wait for the disconnect to complete first if any is ongoing.
+  private async getConnectedClient(name: string, config: MastraMCPServerDefinition): Promise<InternalMastraMCPClient> {
     if (this.disconnectPromise) {
       await this.disconnectPromise;
     }
@@ -197,12 +236,18 @@ To fix this you have three different options:
         `Failed to connect to MCP server ${name}: ${e instanceof Error ? e.stack || e.message : String(e)}`,
       );
     }
-
     this.logger.debug(`Connected to ${name} MCP server`);
-
     return mcpClient;
   }
 
+  private async getConnectedClientForServer(serverName: string): Promise<InternalMastraMCPClient> {
+    const serverConfig = this.serverConfigs[serverName];
+    if (!serverConfig) {
+      throw new Error(`Server configuration not found for name: ${serverName}`);
+    }
+    return this.getConnectedClient(serverName, serverConfig);
+  }
+
   private async eachClientTools(
     cb: (args: {
       serverName: string;
@@ -218,35 +263,6 @@ 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),
-          });
-        }
-      }),
-    );
-  }
 }
 
 /**

package/src/client/resourceActions.ts

@@ -0,0 +1,121 @@
+import type { IMastraLogger } from "@mastra/core/logger";
+import { ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+import type { Resource, ResourceTemplate } from "@modelcontextprotocol/sdk/types.js";
+import type { InternalMastraMCPClient } from "./client";
+
+interface ResourceClientActionsConfig {
+  client: InternalMastraMCPClient;
+  logger: IMastraLogger;
+}
+
+export class ResourceClientActions {
+  private readonly client: InternalMastraMCPClient;
+  private readonly logger: IMastraLogger;
+
+  constructor({ client, logger }: ResourceClientActionsConfig) {
+    this.client = client;
+    this.logger = logger;
+  }
+
+  /**
+   * Get all resources from the connected MCP server.
+   * @returns A list of resources.
+   */
+  public async list(): Promise<Resource[]> {
+    try {
+      const response = await this.client.listResources();
+      if (response && response.resources && Array.isArray(response.resources)) {
+        return response.resources;
+      } else {
+        this.logger.warn(`Resources response from server ${this.client.name} did not have expected structure.`, {
+          response,
+        });
+        return [];
+      }
+    } catch (e: any) {
+      // MCP Server might not support resources, so we return an empty array
+      if (e.code === ErrorCode.MethodNotFound) {      
+        return []
+      }
+      this.logger.error(`Error getting resources from server ${this.client.name}`, {
+        error: e instanceof Error ? e.message : String(e),
+      });
+      console.log('errorheere', e)
+      throw new Error(
+        `Failed to fetch resources from server ${this.client.name}: ${e instanceof Error ? e.stack || e.message : String(e)}`,
+      );
+    }
+  }
+
+  /**
+   * Get all resource templates from the connected MCP server.
+   * @returns A list of resource templates.
+   */
+  public async templates(): Promise<ResourceTemplate[]> {
+    try {
+      const response = await this.client.listResourceTemplates();
+      if (response && response.resourceTemplates && Array.isArray(response.resourceTemplates)) {
+        return response.resourceTemplates;
+      } else {
+        this.logger.warn(
+          `Resource templates response from server ${this.client.name} did not have expected structure.`,
+          { response },
+        );
+        return [];
+      }
+    } catch (e: any) {
+      // MCP Server might not support resources, so we return an empty array
+      console.log({ errorcooode: e.code })
+      if (e.code === ErrorCode.MethodNotFound) {      
+        return []
+      }
+      this.logger.error(`Error getting resource templates from server ${this.client.name}`, {
+        error: e instanceof Error ? e.message : String(e),
+      });
+      throw new Error(
+        `Failed to fetch resource templates from server ${this.client.name}: ${e instanceof Error ? e.stack || e.message : String(e)}`,
+      );
+    }
+  }
+
+  /**
+   * Read a specific resource.
+   * @param uri The URI of the resource to read.
+   * @returns The resource content.
+   */
+  public async read(uri: string) {
+    return this.client.readResource(uri);
+  }
+
+  /**
+   * Subscribe to a specific resource.
+   * @param uri The URI of the resource to subscribe to.
+   */
+  public async subscribe(uri: string) {
+    return this.client.subscribeResource(uri);
+  }
+
+  /**
+   * Unsubscribe from a specific resource.
+   * @param uri The URI of the resource to unsubscribe from.
+   */
+  public async unsubscribe(uri: string) {
+    return this.client.unsubscribeResource(uri);
+  }
+
+  /**
+   * Set a notification handler for when a specific resource is updated.
+   * @param handler The callback function to handle the notification.
+   */
+  public async onUpdated(handler: (params: { uri: string }) => void): Promise<void> {
+    this.client.setResourceUpdatedNotificationHandler(handler);
+  }
+
+  /**
+   * Set a notification handler for when the list of available resources changes.
+   * @param handler The callback function to handle the notification.
+   */
+  public async onListChanged(handler: () => void): Promise<void> {
+    this.client.setResourceListChangedNotificationHandler(handler);
+  }
+}

package/src/index.ts

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

package/src/server/resourceActions.ts

@@ -0,0 +1,62 @@
+import type { IMastraLogger } from '@mastra/core/logger';
+import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
+
+interface ServerResourceActionsDependencies {
+  getSubscriptions: () => Set<string>;
+  getLogger: () => IMastraLogger;
+  getSdkServer: () => Server;
+  clearDefinedResources: () => void;
+  clearDefinedResourceTemplates: () => void;
+}
+
+export class ServerResourceActions {
+  private readonly getSubscriptions: () => Set<string>;
+  private readonly getLogger: () => IMastraLogger;
+  private readonly getSdkServer: () => Server;
+  private readonly clearDefinedResources: () => void;
+  private readonly clearDefinedResourceTemplates: () => void;
+
+  constructor(dependencies: ServerResourceActionsDependencies) {
+    this.getSubscriptions = dependencies.getSubscriptions;
+    this.getLogger = dependencies.getLogger;
+    this.getSdkServer = dependencies.getSdkServer;
+    this.clearDefinedResources = dependencies.clearDefinedResources;
+    this.clearDefinedResourceTemplates = dependencies.clearDefinedResourceTemplates;
+  }
+
+  /**
+   * Checks if any resources have been updated.
+   * If the resource is subscribed to by clients, an update notification will be sent.
+   */
+  public async notifyUpdated({ uri }: { uri: string }): Promise<void> {
+    if (this.getSubscriptions().has(uri)) {
+      this.getLogger().info(`Sending notifications/resources/updated for externally notified resource: ${uri}`);
+      try {
+        await this.getSdkServer().sendResourceUpdated({ uri });
+      } catch (error) {
+        this.getLogger().error('Failed to send resource updated notification:', { error });
+        throw error;
+      }
+    } else {
+      this.getLogger().debug(`Resource ${uri} was updated, but no active subscriptions for it.`);
+    }
+  }
+
+  /**
+   * Notifies the server that the overall list of available resources has changed.
+   * This will clear the internal cache of defined resources and send a list_changed notification to clients.
+   */
+  public async notifyListChanged(): Promise<void> {
+    this.getLogger().info(
+      'Resource list change externally notified. Clearing definedResources and sending notification.',
+    );
+    this.clearDefinedResources(); // Clear cached resources
+    this.clearDefinedResourceTemplates(); // Clear cached resource templates
+    try {
+      await this.getSdkServer().sendResourceListChanged();
+    } catch (error) {
+      this.getLogger().error('Failed to send resource list changed notification:', { error });
+      throw error;
+    }
+  }
+}