@mastra/mcp 0.10.0 → 0.10.1

package/dist/index.cjs

@@ -16,6 +16,7 @@ var equal = require('fast-deep-equal');
 var uuid = require('uuid');
 var crypto$1 = require('crypto');
 var core = require('@mastra/core');
+var agent = require('@mastra/core/agent');
 var mcp = require('@mastra/core/mcp');
 var runtimeContext = require('@mastra/core/runtime-context');
 var index_js = require('@modelcontextprotocol/sdk/server/index.js');
@@ -28,7 +29,110 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var equal__default = /*#__PURE__*/_interopDefault(equal);
 
-// src/client.ts
+// src/client/client.ts
+var ResourceClientActions = class {
+  client;
+  logger;
+  constructor({ client, logger }) {
+    this.client = client;
+    this.logger = logger;
+  }
+  /**
+   * Get all resources from the connected MCP server.
+   * @returns A list of resources.
+   */
+  async list() {
+    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) {
+      if (e.code === types_js.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.
+   */
+  async templates() {
+    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) {
+      console.log({ errorcooode: e.code });
+      if (e.code === types_js.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.
+   */
+  async read(uri) {
+    return this.client.readResource(uri);
+  }
+  /**
+   * Subscribe to a specific resource.
+   * @param uri The URI of the resource to subscribe to.
+   */
+  async subscribe(uri) {
+    return this.client.subscribeResource(uri);
+  }
+  /**
+   * Unsubscribe from a specific resource.
+   * @param uri The URI of the resource to unsubscribe from.
+   */
+  async unsubscribe(uri) {
+    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.
+   */
+  async onUpdated(handler) {
+    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.
+   */
+  async onListChanged(handler) {
+    this.client.setResourceListChangedNotificationHandler(handler);
+  }
+};
+
+// src/client/client.ts
 function convertLogLevelToLoggerMethod(level) {
   switch (level) {
     case "debug":
@@ -56,6 +160,7 @@ var InternalMastraMCPClient = class extends base.MastraBase {
   serverConfig;
   transport;
   currentOperationContext = null;
+  resources;
   constructor({
     name,
     version = "1.0.0",
@@ -79,6 +184,7 @@ var InternalMastraMCPClient = class extends base.MastraBase {
       }
     );
     this.setupLogging();
+    this.resources = new ResourceClientActions({ client: this, logger: this.logger });
   }
   /**
    * Log a message at the specified level
@@ -232,13 +338,48 @@ var InternalMastraMCPClient = class extends base.MastraBase {
       this.isConnected = false;
     }
   }
-  // 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() {
+  async listResources() {
     this.log("debug", `Requesting resources from MCP server`);
     return await this.client.request({ method: "resources/list" }, types_js.ListResourcesResultSchema, {
       timeout: this.timeout
     });
   }
+  async readResource(uri) {
+    this.log("debug", `Reading resource from MCP server: ${uri}`);
+    return await this.client.request({ method: "resources/read", params: { uri } }, types_js.ReadResourceResultSchema, {
+      timeout: this.timeout
+    });
+  }
+  async subscribeResource(uri) {
+    this.log("debug", `Subscribing to resource on MCP server: ${uri}`);
+    return await this.client.request({ method: "resources/subscribe", params: { uri } }, zod.z.object({}), {
+      timeout: this.timeout
+    });
+  }
+  async unsubscribeResource(uri) {
+    this.log("debug", `Unsubscribing from resource on MCP server: ${uri}`);
+    return await this.client.request({ method: "resources/unsubscribe", params: { uri } }, zod.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" }, types_js.ListResourceTemplatesResultSchema, {
+      timeout: this.timeout
+    });
+  }
+  setResourceUpdatedNotificationHandler(handler) {
+    this.log("debug", "Setting resource updated notification handler");
+    this.client.setNotificationHandler(types_js.ResourceUpdatedNotificationSchema, (notification) => {
+      handler(notification.params);
+    });
+  }
+  setResourceListChangedNotificationHandler(handler) {
+    this.log("debug", "Setting resource list changed notification handler");
+    this.client.setNotificationHandler(types_js.ResourceListChangedNotificationSchema, () => {
+      handler();
+    });
+  }
   convertInputSchema(inputSchema) {
     if (utils.isZodType(inputSchema)) {
       return inputSchema;
@@ -342,6 +483,7 @@ var MCPClient = class extends base.MastraBase {
         const existingInstance2 = mcpClientInstances.get(this.id);
         if (existingInstance2) {
           void existingInstance2.disconnect();
+          mcpClientInstances.delete(this.id);
         }
       }
     } else {
@@ -366,6 +508,55 @@ To fix this you have three different options:
     this.addToInstanceCache();
     return this;
   }
+  get resources() {
+    this.addToInstanceCache();
+    return {
+      list: async () => {
+        const allResources = {};
+        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 () => {
+        const allTemplates = {};
+        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, uri) => {
+        const internalClient = await this.getConnectedClientForServer(serverName);
+        return internalClient.resources.read(uri);
+      },
+      subscribe: async (serverName, uri) => {
+        const internalClient = await this.getConnectedClientForServer(serverName);
+        return internalClient.resources.subscribe(uri);
+      },
+      unsubscribe: async (serverName, uri) => {
+        const internalClient = await this.getConnectedClientForServer(serverName);
+        return internalClient.resources.unsubscribe(uri);
+      },
+      onUpdated: async (serverName, handler) => {
+        const internalClient = await this.getConnectedClientForServer(serverName);
+        return internalClient.resources.onUpdated(handler);
+      },
+      onListChanged: async (serverName, handler) => {
+        const internalClient = await this.getConnectedClientForServer(serverName);
+        return internalClient.resources.onListChanged(handler);
+      }
+    };
+  }
   addToInstanceCache() {
     if (!mcpClientInstances.has(this.id)) {
       mcpClientInstances.set(this.id, this);
@@ -412,18 +603,10 @@ 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
+   * @deprecated all resource actions have been moved to the this.resources object. Use this.resources.list() instead.
    */
   async getResources() {
-    this.addToInstanceCache();
-    const connectedResources = {};
-    await this.eachClientResources(async ({ serverName, resources }) => {
-      if (resources && Array.isArray(resources)) {
-        connectedResources[serverName] = resources;
-      }
-    });
-    return connectedResources;
+    return this.resources.list();
   }
   /**
    * Get the current session IDs for all connected MCP clients using the Streamable HTTP transport.
@@ -472,6 +655,13 @@ To fix this you have three different options:
     this.logger.debug(`Connected to ${name} MCP server`);
     return mcpClient;
   }
+  async getConnectedClientForServer(serverName) {
+    const serverConfig = this.serverConfigs[serverName];
+    if (!serverConfig) {
+      throw new Error(`Server configuration not found for name: ${serverName}`);
+    }
+    return this.getConnectedClient(serverName, serverConfig);
+  }
   async eachClientTools(cb) {
     await Promise.all(
       Object.entries(this.serverConfigs).map(async ([serverName, serverConfig]) => {
@@ -481,27 +671,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
-   */
-  async eachClientResources(cb) {
-    await Promise.all(
-      Object.entries(this.serverConfigs).map(async ([serverName, serverConfig]) => {
-        try {
-          const client = await this.getConnectedClient(serverName, serverConfig);
-          const response = await client.resources();
-          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)
-          });
-        }
-      })
-    );
-  }
 };
 var MCPConfiguration = class extends MCPClient {
   constructor(args) {
@@ -595,6 +764,58 @@ var SSETransport = class {
     });
   }
 };
+
+// src/server/resourceActions.ts
+var ServerResourceActions = class {
+  getSubscriptions;
+  getLogger;
+  getSdkServer;
+  clearDefinedResources;
+  clearDefinedResourceTemplates;
+  constructor(dependencies) {
+    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.
+   */
+  async notifyUpdated({ uri }) {
+    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.
+   */
+  async notifyListChanged() {
+    this.getLogger().info(
+      "Resource list change externally notified. Clearing definedResources and sending notification."
+    );
+    this.clearDefinedResources();
+    this.clearDefinedResourceTemplates();
+    try {
+      await this.getSdkServer().sendResourceListChanged();
+    } catch (error) {
+      this.getLogger().error("Failed to send resource list changed notification:", { error });
+      throw error;
+    }
+  }
+};
+
+// src/server/server.ts
 var MCPServer = class extends mcp.MCPServerBase {
   server;
   stdioTransport;
@@ -603,6 +824,16 @@ var MCPServer = class extends mcp.MCPServerBase {
   streamableHTTPTransport;
   listToolsHandlerIsRegistered = false;
   callToolHandlerIsRegistered = false;
+  listResourcesHandlerIsRegistered = false;
+  readResourceHandlerIsRegistered = false;
+  listResourceTemplatesHandlerIsRegistered = false;
+  subscribeResourceHandlerIsRegistered = false;
+  unsubscribeResourceHandlerIsRegistered = false;
+  definedResources;
+  definedResourceTemplates;
+  resourceOptions;
+  subscriptions = /* @__PURE__ */ new Set();
+  resources;
   /**
    * Get the current stdio transport.
    */
@@ -633,24 +864,179 @@ var MCPServer = class extends mcp.MCPServerBase {
    */
   constructor(opts) {
     super(opts);
-    this.server = new index_js.Server(
-      { name: this.name, version: this.version },
-      { capabilities: { tools: {}, logging: { enabled: true } } }
-    );
+    this.resourceOptions = opts.resources;
+    const capabilities = {
+      tools: {},
+      logging: { enabled: true }
+    };
+    if (opts.resources) {
+      capabilities.resources = { subscribe: true, listChanged: true };
+    }
+    this.server = new index_js.Server({ name: this.name, version: this.version }, { capabilities });
     this.logger.info(
-      `Initialized MCPServer '${this.name}' v${this.version} (ID: ${this.id}) with tools: ${Object.keys(this.convertedTools).join(", ")}`
+      `Initialized MCPServer '${this.name}' v${this.version} (ID: ${this.id}) with tools: ${Object.keys(this.convertedTools).join(", ")} and resources. Capabilities: ${JSON.stringify(capabilities)}`
     );
     this.sseHonoTransports = /* @__PURE__ */ new Map();
     this.registerListToolsHandler();
     this.registerCallToolHandler();
+    if (opts.resources) {
+      this.registerListResourcesHandler();
+      this.registerReadResourceHandler({ getResourcesCallback: opts.resources.getResourceContent });
+      this.registerSubscribeResourceHandler();
+      this.registerUnsubscribeResourceHandler();
+      if (opts.resources.resourceTemplates) {
+        this.registerListResourceTemplatesHandler();
+      }
+    }
+    this.resources = new ServerResourceActions({
+      getSubscriptions: () => this.subscriptions,
+      getLogger: () => this.logger,
+      getSdkServer: () => this.server,
+      clearDefinedResources: () => {
+        this.definedResources = void 0;
+      },
+      clearDefinedResourceTemplates: () => {
+        this.definedResourceTemplates = void 0;
+      }
+    });
+  }
+  convertAgentsToTools(agentsConfig, definedConvertedTools) {
+    const agentTools = {};
+    if (!agentsConfig) {
+      return agentTools;
+    }
+    for (const agentKey in agentsConfig) {
+      const agent$1 = agentsConfig[agentKey];
+      if (!agent$1 || !(agent$1 instanceof agent.Agent)) {
+        this.logger.warn(`Agent instance for '${agentKey}' is invalid or missing a generate function. Skipping.`);
+        continue;
+      }
+      const agentDescription = agent$1.getDescription();
+      if (!agentDescription) {
+        throw new Error(
+          `Agent '${agent$1.name}' (key: '${agentKey}') must have a non-empty description to be used in an MCPServer.`
+        );
+      }
+      const agentToolName = `ask_${agentKey}`;
+      if (definedConvertedTools?.[agentToolName] || agentTools[agentToolName]) {
+        this.logger.warn(
+          `Tool with name '${agentToolName}' already exists. Agent '${agentKey}' will not be added as a duplicate tool.`
+        );
+        continue;
+      }
+      const agentToolDefinition = core.createTool({
+        id: agentToolName,
+        description: `Ask agent '${agent$1.name}' a question. Agent description: ${agentDescription}`,
+        inputSchema: zod.z.object({
+          message: zod.z.string().describe("The question or input for the agent.")
+        }),
+        execute: async ({ context, runtimeContext }) => {
+          this.logger.debug(
+            `Executing agent tool '${agentToolName}' for agent '${agent$1.name}' with message: "${context.message}"`
+          );
+          try {
+            const response = await agent$1.generate(context.message, { runtimeContext });
+            return response;
+          } catch (error) {
+            this.logger.error(`Error executing agent tool '${agentToolName}' for agent '${agent$1.name}':`, error);
+            throw error;
+          }
+        }
+      });
+      const options = {
+        name: agentToolName,
+        logger: this.logger,
+        mastra: this.mastra,
+        runtimeContext: new runtimeContext.RuntimeContext(),
+        description: agentToolDefinition.description
+      };
+      const coreTool = core.makeCoreTool(agentToolDefinition, options);
+      agentTools[agentToolName] = {
+        name: agentToolName,
+        description: coreTool.description,
+        parameters: coreTool.parameters,
+        execute: coreTool.execute
+      };
+      this.logger.info(`Registered agent '${agent$1.name}' (key: '${agentKey}') as tool: '${agentToolName}'`);
+    }
+    return agentTools;
+  }
+  convertWorkflowsToTools(workflowsConfig, definedConvertedTools) {
+    const workflowTools = {};
+    if (!workflowsConfig) {
+      return workflowTools;
+    }
+    for (const workflowKey in workflowsConfig) {
+      const workflow = workflowsConfig[workflowKey];
+      if (!workflow || typeof workflow.createRun !== "function") {
+        this.logger.warn(
+          `Workflow instance for '${workflowKey}' is invalid or missing a createRun function. Skipping.`
+        );
+        continue;
+      }
+      const workflowDescription = workflow.description;
+      if (!workflowDescription) {
+        throw new Error(
+          `Workflow '${workflow.id}' (key: '${workflowKey}') must have a non-empty description to be used in an MCPServer.`
+        );
+      }
+      const workflowToolName = `run_${workflowKey}`;
+      if (definedConvertedTools?.[workflowToolName] || workflowTools[workflowToolName]) {
+        this.logger.warn(
+          `Tool with name '${workflowToolName}' already exists. Workflow '${workflowKey}' will not be added as a duplicate tool.`
+        );
+        continue;
+      }
+      const workflowToolDefinition = core.createTool({
+        id: workflowToolName,
+        description: `Run workflow '${workflowKey}'. Workflow description: ${workflowDescription}`,
+        inputSchema: workflow.inputSchema,
+        execute: async ({ context, runtimeContext }) => {
+          this.logger.debug(
+            `Executing workflow tool '${workflowToolName}' for workflow '${workflow.id}' with input:`,
+            context
+          );
+          try {
+            const run = workflow.createRun({ runId: runtimeContext?.get("runId") });
+            const response = await run.start({ inputData: context, runtimeContext });
+            return response;
+          } catch (error) {
+            this.logger.error(
+              `Error executing workflow tool '${workflowToolName}' for workflow '${workflow.id}':`,
+              error
+            );
+            throw error;
+          }
+        }
+      });
+      const options = {
+        name: workflowToolName,
+        logger: this.logger,
+        mastra: this.mastra,
+        runtimeContext: new runtimeContext.RuntimeContext(),
+        description: workflowToolDefinition.description
+      };
+      const coreTool = core.makeCoreTool(workflowToolDefinition, options);
+      workflowTools[workflowToolName] = {
+        name: workflowToolName,
+        description: coreTool.description,
+        parameters: coreTool.parameters,
+        execute: coreTool.execute
+      };
+      this.logger.info(`Registered workflow '${workflow.id}' (key: '${workflowKey}') as tool: '${workflowToolName}'`);
+    }
+    return workflowTools;
   }
   /**
    * Convert and validate all provided tools, logging registration status.
+   * Also converts agents and workflows into tools.
    * @param tools Tool definitions
+   * @param agentsConfig Agent definitions to be converted to tools, expected from MCPServerConfig
+   * @param workflowsConfig Workflow definitions to be converted to tools, expected from MCPServerConfig
    * @returns Converted tools registry
    */
-  convertTools(tools) {
-    const convertedTools = {};
+  convertTools(tools, agentsConfig, workflowsConfig) {
+    const definedConvertedTools = {};
     for (const toolName of Object.keys(tools)) {
       const toolInstance = tools[toolName];
       if (!toolInstance) {
@@ -669,16 +1055,26 @@ var MCPServer = class extends mcp.MCPServerBase {
         description: toolInstance?.description
       };
       const coreTool = core.makeCoreTool(toolInstance, options);
-      convertedTools[toolName] = {
+      definedConvertedTools[toolName] = {
         name: toolName,
         description: coreTool.description,
         parameters: coreTool.parameters,
         execute: coreTool.execute
       };
-      this.logger.info(`Registered tool: '${toolName}' [${toolInstance?.description || "No description"}]`);
+      this.logger.info(`Registered explicit tool: '${toolName}'`);
     }
-    this.logger.info(`Total tools registered: ${Object.keys(convertedTools).length}`);
-    return convertedTools;
+    this.logger.info(`Total defined tools registered: ${Object.keys(definedConvertedTools).length}`);
+    const agentDerivedTools = this.convertAgentsToTools(agentsConfig, definedConvertedTools);
+    const workflowDerivedTools = this.convertWorkflowsToTools(workflowsConfig, definedConvertedTools);
+    const allConvertedTools = { ...definedConvertedTools, ...agentDerivedTools, ...workflowDerivedTools };
+    const finalToolCount = Object.keys(allConvertedTools).length;
+    const definedCount = Object.keys(definedConvertedTools).length;
+    const fromAgentsCount = Object.keys(agentDerivedTools).length;
+    const fromWorkflowsCount = Object.keys(workflowDerivedTools).length;
+    this.logger.info(
+      `${finalToolCount} total tools registered (${definedCount} defined + ${fromAgentsCount} agents + ${fromWorkflowsCount} workflows)`
+    );
+    return allConvertedTools;
   }
   /**
    * Register the ListTools handler for listing all available tools.
@@ -774,6 +1170,159 @@ var MCPServer = class extends mcp.MCPServerBase {
       }
     });
   }
+  /**
+   * Register the ListResources handler for listing all available resources.
+   */
+  registerListResourcesHandler() {
+    if (this.listResourcesHandlerIsRegistered) {
+      return;
+    }
+    this.listResourcesHandlerIsRegistered = true;
+    const capturedResourceOptions = this.resourceOptions;
+    if (!capturedResourceOptions?.listResources) {
+      this.logger.warn("ListResources capability not supported by server configuration.");
+      return;
+    }
+    this.server.setRequestHandler(types_js.ListResourcesRequestSchema, async () => {
+      this.logger.debug("Handling ListResources request");
+      if (this.definedResources) {
+        return { resources: this.definedResources };
+      } else {
+        try {
+          const resources = await capturedResourceOptions.listResources();
+          this.definedResources = resources;
+          this.logger.debug(`Fetched and cached ${this.definedResources.length} resources.`);
+          return { resources: this.definedResources };
+        } catch (error) {
+          this.logger.error("Error fetching resources via listResources():", { error });
+          throw error;
+        }
+      }
+    });
+  }
+  /**
+   * Register the ReadResource handler for reading a resource by URI.
+   */
+  registerReadResourceHandler({
+    getResourcesCallback
+  }) {
+    if (this.readResourceHandlerIsRegistered) {
+      return;
+    }
+    this.readResourceHandlerIsRegistered = true;
+    this.server.setRequestHandler(types_js.ReadResourceRequestSchema, async (request) => {
+      const startTime = Date.now();
+      const uri = request.params.uri;
+      this.logger.debug(`Handling ReadResource request for URI: ${uri}`);
+      if (!this.definedResources) {
+        const resources = await this.resourceOptions?.listResources?.();
+        if (!resources) throw new Error("Failed to load resources");
+        this.definedResources = resources;
+      }
+      const resource = this.definedResources?.find((r) => r.uri === uri);
+      if (!resource) {
+        this.logger.warn(`ReadResource: Unknown resource URI '${uri}' requested.`);
+        throw new Error(`Resource not found: ${uri}`);
+      }
+      try {
+        const resourcesOrResourceContent = await getResourcesCallback({ uri });
+        const resourcesContent = Array.isArray(resourcesOrResourceContent) ? resourcesOrResourceContent : [resourcesOrResourceContent];
+        const contents = resourcesContent.map((resourceContent) => {
+          const contentItem = {
+            uri: resource.uri,
+            mimeType: resource.mimeType
+          };
+          if ("text" in resourceContent) {
+            contentItem.text = resourceContent.text;
+          }
+          if ("blob" in resourceContent) {
+            contentItem.blob = resourceContent.blob;
+          }
+          return contentItem;
+        });
+        const duration = Date.now() - startTime;
+        this.logger.info(`Resource '${uri}' read successfully in ${duration}ms.`);
+        return {
+          contents
+        };
+      } catch (error) {
+        const duration = Date.now() - startTime;
+        this.logger.error(`Failed to get content for resource URI '${uri}' in ${duration}ms`, { error });
+        throw error;
+      }
+    });
+  }
+  /**
+   * Register the ListResourceTemplates handler.
+   */
+  registerListResourceTemplatesHandler() {
+    if (this.listResourceTemplatesHandlerIsRegistered) {
+      return;
+    }
+    if (!this.resourceOptions || typeof this.resourceOptions.resourceTemplates !== "function") {
+      this.logger.warn(
+        "ListResourceTemplates handler called, but resourceTemplates function is not available on resourceOptions or not a function."
+      );
+      this.server.setRequestHandler(types_js.ListResourceTemplatesRequestSchema, async () => {
+        this.logger.debug("Handling ListResourceTemplates request (no templates configured or resourceOptions issue)");
+        return { resourceTemplates: [] };
+      });
+      this.listResourceTemplatesHandlerIsRegistered = true;
+      return;
+    }
+    const resourceTemplatesFn = this.resourceOptions.resourceTemplates;
+    this.listResourceTemplatesHandlerIsRegistered = true;
+    this.server.setRequestHandler(types_js.ListResourceTemplatesRequestSchema, async () => {
+      this.logger.debug("Handling ListResourceTemplates request");
+      if (this.definedResourceTemplates) {
+        return { resourceTemplates: this.definedResourceTemplates };
+      } else {
+        try {
+          const templates = await resourceTemplatesFn();
+          this.definedResourceTemplates = templates;
+          this.logger.debug(`Fetched and cached ${this.definedResourceTemplates.length} resource templates.`);
+          return { resourceTemplates: this.definedResourceTemplates };
+        } catch (error) {
+          this.logger.error("Error fetching resource templates via resourceTemplates():", { error });
+          throw error;
+        }
+      }
+    });
+  }
+  /**
+   * Register the SubscribeResource handler.
+   */
+  registerSubscribeResourceHandler() {
+    if (this.subscribeResourceHandlerIsRegistered) {
+      return;
+    }
+    if (!types_js.SubscribeRequestSchema) {
+      this.logger.warn("SubscribeRequestSchema not available, cannot register SubscribeResource handler.");
+      return;
+    }
+    this.subscribeResourceHandlerIsRegistered = true;
+    this.server.setRequestHandler(types_js.SubscribeRequestSchema, async (request) => {
+      const uri = request.params.uri;
+      this.logger.info(`Received resources/subscribe request for URI: ${uri}`);
+      this.subscriptions.add(uri);
+      return {};
+    });
+  }
+  /**
+   * Register the UnsubscribeResource handler.
+   */
+  registerUnsubscribeResourceHandler() {
+    if (this.unsubscribeResourceHandlerIsRegistered) {
+      return;
+    }
+    this.unsubscribeResourceHandlerIsRegistered = true;
+    this.server.setRequestHandler(types_js.UnsubscribeRequestSchema, async (request) => {
+      const uri = request.params.uri;
+      this.logger.info(`Received resources/unsubscribe request for URI: ${uri}`);
+      this.subscriptions.delete(uri);
+      return {};
+    });
+  }
   /**
    * Start the MCP server using stdio transport (for Windsurf integration).
    */
@@ -940,6 +1489,11 @@ var MCPServer = class extends mcp.MCPServerBase {
   async close() {
     this.callToolHandlerIsRegistered = false;
     this.listToolsHandlerIsRegistered = false;
+    this.listResourcesHandlerIsRegistered = false;
+    this.readResourceHandlerIsRegistered = false;
+    this.listResourceTemplatesHandlerIsRegistered = false;
+    this.subscribeResourceHandlerIsRegistered = false;
+    this.unsubscribeResourceHandlerIsRegistered = false;
     try {
       if (this.stdioTransport) {
         await this.stdioTransport.close?.();