@mastra/mcp 0.10.5-alpha.1 → 0.10.5

package/dist/index.cjs

@@ -29,6 +29,23 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 var equal__default = /*#__PURE__*/_interopDefault(equal);
 
 // src/client/client.ts
+
+// src/client/elicitationActions.ts
+var ElicitationClientActions = class {
+  client;
+  logger;
+  constructor({ client, logger }) {
+    this.client = client;
+    this.logger = logger;
+  }
+  /**
+   * Set a handler for elicitation requests.
+   * @param handler The callback function to handle the elicitation request.
+   */
+  onRequest(handler) {
+    this.client.setElicitationRequestHandler(handler);
+  }
+};
 var PromptClientActions = class {
   client;
   logger;
@@ -211,6 +228,7 @@ var InternalMastraMCPClient = class extends base.MastraBase {
   currentOperationContext = null;
   resources;
   prompts;
+  elicitation;
   constructor({
     name,
     version = "1.0.0",
@@ -224,18 +242,20 @@ var InternalMastraMCPClient = class extends base.MastraBase {
     this.logHandler = server.logger;
     this.enableServerLogs = server.enableServerLogs ?? true;
     this.serverConfig = server;
+    const clientCapabilities = { ...capabilities, elicitation: {} };
     this.client = new index_js$1.Client(
       {
         name,
         version
       },
       {
-        capabilities
+        capabilities: clientCapabilities
       }
     );
     this.setupLogging();
     this.resources = new ResourceClientActions({ client: this, logger: this.logger });
     this.prompts = new PromptClientActions({ client: this, logger: this.logger });
+    this.elicitation = new ElicitationClientActions({ client: this, logger: this.logger });
   }
   /**
    * Log a message at the specified level
@@ -477,6 +497,13 @@ var InternalMastraMCPClient = class extends base.MastraBase {
       handler();
     });
   }
+  setElicitationRequestHandler(handler) {
+    this.log("debug", "Setting elicitation request handler");
+    this.client.setRequestHandler(types_js.ElicitRequestSchema, async (request) => {
+      this.log("debug", `Received elicitation request: ${request.params.message}`);
+      return handler(request.params);
+    });
+  }
   convertInputSchema(inputSchema) {
     if (utils.isZodType(inputSchema)) {
       return inputSchema;
@@ -641,6 +668,26 @@ To fix this you have three different options:
     this.addToInstanceCache();
     return this;
   }
+  get elicitation() {
+    this.addToInstanceCache();
+    return {
+      onRequest: async (serverName, handler) => {
+        try {
+          const internalClient = await this.getConnectedClientForServer(serverName);
+          return internalClient.elicitation.onRequest(handler);
+        } catch (err) {
+          throw new error.MastraError({
+            id: "MCP_CLIENT_ON_REQUEST_ELICITATION_FAILED",
+            domain: error.ErrorDomain.MCP,
+            category: error.ErrorCategory.THIRD_PARTY,
+            details: {
+              serverName
+            }
+          }, err);
+        }
+      }
+    };
+  }
   get resources() {
     this.addToInstanceCache();
     return {
@@ -1336,15 +1383,8 @@ var MCPServer = class extends mcp.MCPServerBase {
   sseTransport;
   sseHonoTransports;
   streamableHTTPTransports = /* @__PURE__ */ new Map();
-  listToolsHandlerIsRegistered = false;
-  callToolHandlerIsRegistered = false;
-  listResourcesHandlerIsRegistered = false;
-  readResourceHandlerIsRegistered = false;
-  listResourceTemplatesHandlerIsRegistered = false;
-  subscribeResourceHandlerIsRegistered = false;
-  unsubscribeResourceHandlerIsRegistered = false;
-  listPromptsHandlerIsRegistered = false;
-  getPromptHandlerIsRegistered = false;
+  // Track server instances for each HTTP session
+  httpServerInstances = /* @__PURE__ */ new Map();
   definedResources;
   definedResourceTemplates;
   resourceOptions;
@@ -1353,6 +1393,7 @@ var MCPServer = class extends mcp.MCPServerBase {
   subscriptions = /* @__PURE__ */ new Set();
   resources;
   prompts;
+  elicitation;
   /**
    * Get the current stdio transport.
    */
@@ -1387,7 +1428,8 @@ var MCPServer = class extends mcp.MCPServerBase {
     this.promptOptions = opts.prompts;
     const capabilities = {
       tools: {},
-      logging: { enabled: true }
+      logging: { enabled: true },
+      elicitation: {}
     };
     if (opts.resources) {
       capabilities.resources = { subscribe: true, listChanged: true };
@@ -1400,23 +1442,7 @@ var MCPServer = class extends mcp.MCPServerBase {
       `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();
-      }
-    }
-    if (opts.prompts) {
-      this.registerListPromptsHandler();
-      this.registerGetPromptHandler({
-        getPromptMessagesCallback: opts.prompts.getPromptMessages
-      });
-    }
+    this.registerHandlersOnServer(this.server);
     this.resources = new ServerResourceActions({
       getSubscriptions: () => this.subscriptions,
       getLogger: () => this.logger,
@@ -1435,6 +1461,342 @@ var MCPServer = class extends mcp.MCPServerBase {
         this.definedPrompts = void 0;
       }
     });
+    this.elicitation = {
+      sendRequest: async (request) => {
+        return this.handleElicitationRequest(request);
+      }
+    };
+  }
+  /**
+   * Handle an elicitation request by sending it to the connected client.
+   * This method sends an elicitation/create request to the client and waits for the response.
+   *
+   * @param request - The elicitation request containing message and schema
+   * @param serverInstance - Optional server instance to use; defaults to main server for backward compatibility
+   * @returns Promise that resolves to the client's response
+   */
+  async handleElicitationRequest(request, serverInstance) {
+    this.logger.debug(`Sending elicitation request: ${request.message}`);
+    const server = serverInstance || this.server;
+    const response = await server.elicitInput(request);
+    this.logger.debug(`Received elicitation response: ${JSON.stringify(response)}`);
+    return response;
+  }
+  /**
+   * Creates a new Server instance configured with all handlers for HTTP sessions.
+   * Each HTTP client connection gets its own Server instance to avoid routing conflicts.
+   */
+  createServerInstance() {
+    const capabilities = {
+      tools: {},
+      logging: { enabled: true },
+      elicitation: {}
+    };
+    if (this.resourceOptions) {
+      capabilities.resources = { subscribe: true, listChanged: true };
+    }
+    if (this.promptOptions) {
+      capabilities.prompts = { listChanged: true };
+    }
+    const serverInstance = new index_js.Server({ name: this.name, version: this.version }, { capabilities });
+    this.registerHandlersOnServer(serverInstance);
+    return serverInstance;
+  }
+  /**
+   * Registers all MCP handlers on a given server instance.
+   * This allows us to create multiple server instances with identical functionality.
+   */
+  registerHandlersOnServer(serverInstance) {
+    serverInstance.setRequestHandler(types_js.ListToolsRequestSchema, async () => {
+      this.logger.debug("Handling ListTools request");
+      return {
+        tools: Object.values(this.convertedTools).map((tool) => {
+          const toolSpec = {
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.parameters.jsonSchema
+          };
+          if (tool.outputSchema) {
+            toolSpec.outputSchema = tool.outputSchema.jsonSchema;
+          }
+          return toolSpec;
+        })
+      };
+    });
+    serverInstance.setRequestHandler(types_js.CallToolRequestSchema, async (request) => {
+      const startTime = Date.now();
+      try {
+        const tool = this.convertedTools[request.params.name];
+        if (!tool) {
+          this.logger.warn(`CallTool: Unknown tool '${request.params.name}' requested.`);
+          return {
+            content: [{ type: "text", text: `Unknown tool: ${request.params.name}` }],
+            isError: true
+          };
+        }
+        const validation = tool.parameters.validate?.(request.params.arguments ?? {});
+        if (validation && !validation.success) {
+          this.logger.warn(`CallTool: Invalid tool arguments for '${request.params.name}'`, {
+            errors: validation.error
+          });
+          return {
+            content: [{ type: "text", text: `Invalid tool arguments: ${JSON.stringify(validation.error)}` }],
+            isError: true
+          };
+        }
+        if (!tool.execute) {
+          this.logger.warn(`CallTool: Tool '${request.params.name}' does not have an execute function.`);
+          return {
+            content: [{ type: "text", text: `Tool '${request.params.name}' does not have an execute function.` }],
+            isError: true
+          };
+        }
+        const sessionElicitation = {
+          sendRequest: async (request2) => {
+            return this.handleElicitationRequest(request2, serverInstance);
+          }
+        };
+        const result = await tool.execute(validation?.value, {
+          messages: [],
+          toolCallId: "",
+          elicitation: sessionElicitation
+        });
+        this.logger.debug(`CallTool: Tool '${request.params.name}' executed successfully with result:`, result);
+        const duration = Date.now() - startTime;
+        this.logger.info(`Tool '${request.params.name}' executed successfully in ${duration}ms.`);
+        const response = { isError: false, content: [] };
+        if (tool.outputSchema) {
+          if (!result.structuredContent) {
+            throw new Error(`Tool ${request.params.name} has an output schema but no structured content was provided.`);
+          }
+          const outputValidation = tool.outputSchema.validate?.(result.structuredContent ?? {});
+          if (outputValidation && !outputValidation.success) {
+            this.logger.warn(`CallTool: Invalid structured content for '${request.params.name}'`, {
+              errors: outputValidation.error
+            });
+            throw new Error(
+              `Invalid structured content for tool ${request.params.name}: ${JSON.stringify(outputValidation.error)}`
+            );
+          }
+          response.structuredContent = result.structuredContent;
+        }
+        if (response.structuredContent) {
+          response.content = [{ type: "text", text: JSON.stringify(response.structuredContent) }];
+        } else {
+          response.content = [
+            {
+              type: "text",
+              text: typeof result === "string" ? result : JSON.stringify(result)
+            }
+          ];
+        }
+        return response;
+      } catch (error) {
+        const duration = Date.now() - startTime;
+        if (error instanceof zod.z.ZodError) {
+          this.logger.warn("Invalid tool arguments", {
+            tool: request.params.name,
+            errors: error.errors,
+            duration: `${duration}ms`
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Invalid arguments: ${error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ")}`
+              }
+            ],
+            isError: true
+          };
+        }
+        this.logger.error(`Tool execution failed: ${request.params.name}`, { error });
+        return {
+          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    });
+    if (this.resourceOptions) {
+      this.registerResourceHandlersOnServer(serverInstance);
+    }
+    if (this.promptOptions) {
+      this.registerPromptHandlersOnServer(serverInstance);
+    }
+  }
+  /**
+   * Registers resource-related handlers on a server instance.
+   */
+  registerResourceHandlersOnServer(serverInstance) {
+    const capturedResourceOptions = this.resourceOptions;
+    if (!capturedResourceOptions) return;
+    if (capturedResourceOptions.listResources) {
+      serverInstance.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;
+          }
+        }
+      });
+    }
+    if (capturedResourceOptions.getResourceContent) {
+      serverInstance.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 capturedResourceOptions.getResourceContent({ 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;
+        }
+      });
+    }
+    if (capturedResourceOptions.resourceTemplates) {
+      serverInstance.setRequestHandler(types_js.ListResourceTemplatesRequestSchema, async () => {
+        this.logger.debug("Handling ListResourceTemplates request");
+        if (this.definedResourceTemplates) {
+          return { resourceTemplates: this.definedResourceTemplates };
+        } else {
+          try {
+            const templates = await capturedResourceOptions.resourceTemplates();
+            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;
+          }
+        }
+      });
+    }
+    serverInstance.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 {};
+    });
+    serverInstance.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 {};
+    });
+  }
+  /**
+   * Registers prompt-related handlers on a server instance.
+   */
+  registerPromptHandlersOnServer(serverInstance) {
+    const capturedPromptOptions = this.promptOptions;
+    if (!capturedPromptOptions) return;
+    if (capturedPromptOptions.listPrompts) {
+      serverInstance.setRequestHandler(types_js.ListPromptsRequestSchema, async () => {
+        this.logger.debug("Handling ListPrompts request");
+        if (this.definedPrompts) {
+          return {
+            prompts: this.definedPrompts?.map((p) => ({ ...p, version: p.version ?? void 0 }))
+          };
+        } else {
+          try {
+            const prompts = await capturedPromptOptions.listPrompts();
+            for (const prompt of prompts) {
+              types_js.PromptSchema.parse(prompt);
+            }
+            this.definedPrompts = prompts;
+            this.logger.debug(`Fetched and cached ${this.definedPrompts.length} prompts.`);
+            return {
+              prompts: this.definedPrompts?.map((p) => ({ ...p, version: p.version ?? void 0 }))
+            };
+          } catch (error) {
+            this.logger.error("Error fetching prompts via listPrompts():", {
+              error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+          }
+        }
+      });
+    }
+    if (capturedPromptOptions.getPromptMessages) {
+      serverInstance.setRequestHandler(
+        types_js.GetPromptRequestSchema,
+        async (request) => {
+          const startTime = Date.now();
+          const { name, version, arguments: args } = request.params;
+          if (!this.definedPrompts) {
+            const prompts = await this.promptOptions?.listPrompts?.();
+            if (!prompts) throw new Error("Failed to load prompts");
+            this.definedPrompts = prompts;
+          }
+          let prompt;
+          if (version) {
+            prompt = this.definedPrompts?.find((p) => p.name === name && p.version === version);
+          } else {
+            prompt = this.definedPrompts?.find((p) => p.name === name);
+          }
+          if (!prompt) throw new Error(`Prompt "${name}"${version ? ` (version ${version})` : ""} not found`);
+          if (prompt.arguments) {
+            for (const arg of prompt.arguments) {
+              if (arg.required && (args?.[arg.name] === void 0 || args?.[arg.name] === null)) {
+                throw new Error(`Missing required argument: ${arg.name}`);
+              }
+            }
+          }
+          try {
+            let messages = [];
+            if (capturedPromptOptions.getPromptMessages) {
+              messages = await capturedPromptOptions.getPromptMessages({ name, version, args });
+            }
+            const duration = Date.now() - startTime;
+            this.logger.info(
+              `Prompt '${name}'${version ? ` (version ${version})` : ""} retrieved successfully in ${duration}ms.`
+            );
+            return { prompt, messages };
+          } catch (error) {
+            const duration = Date.now() - startTime;
+            this.logger.error(`Failed to get content for prompt '${name}' in ${duration}ms`, { error });
+            throw error;
+          }
+        }
+      );
+    }
   }
   convertAgentsToTools(agentsConfig, definedConvertedTools) {
     const agentTools = {};
@@ -1634,368 +1996,6 @@ var MCPServer = class extends mcp.MCPServerBase {
     );
     return allConvertedTools;
   }
-  /**
-   * Register the ListTools handler for listing all available tools.
-   */
-  registerListToolsHandler() {
-    if (this.listToolsHandlerIsRegistered) {
-      return;
-    }
-    this.listToolsHandlerIsRegistered = true;
-    this.server.setRequestHandler(types_js.ListToolsRequestSchema, async () => {
-      this.logger.debug("Handling ListTools request");
-      return {
-        tools: Object.values(this.convertedTools).map((tool) => {
-          const toolSpec = {
-            name: tool.name,
-            description: tool.description,
-            inputSchema: tool.parameters.jsonSchema
-          };
-          if (tool.outputSchema) {
-            toolSpec.outputSchema = tool.outputSchema.jsonSchema;
-          }
-          return toolSpec;
-        })
-      };
-    });
-  }
-  /**
-   * Register the CallTool handler for executing a tool by name.
-   */
-  registerCallToolHandler() {
-    if (this.callToolHandlerIsRegistered) {
-      return;
-    }
-    this.callToolHandlerIsRegistered = true;
-    this.server.setRequestHandler(types_js.CallToolRequestSchema, async (request) => {
-      const startTime = Date.now();
-      try {
-        const tool = this.convertedTools[request.params.name];
-        if (!tool) {
-          this.logger.warn(`CallTool: Unknown tool '${request.params.name}' requested.`);
-          return {
-            content: [{ type: "text", text: `Unknown tool: ${request.params.name}` }],
-            isError: true
-          };
-        }
-        const validation = tool.parameters.validate?.(request.params.arguments ?? {});
-        if (validation && !validation.success) {
-          this.logger.warn(`CallTool: Invalid tool arguments for '${request.params.name}'`, {
-            errors: validation.error
-          });
-          return {
-            content: [{ type: "text", text: `Invalid tool arguments: ${JSON.stringify(validation.error)}` }],
-            isError: true
-          };
-        }
-        if (!tool.execute) {
-          this.logger.warn(`CallTool: Tool '${request.params.name}' does not have an execute function.`);
-          return {
-            content: [{ type: "text", text: `Tool '${request.params.name}' does not have an execute function.` }],
-            isError: true
-          };
-        }
-        const result = await tool.execute(validation?.value, { messages: [], toolCallId: "" });
-        this.logger.debug(`CallTool: Tool '${request.params.name}' executed successfully with result:`, result);
-        const duration = Date.now() - startTime;
-        this.logger.info(`Tool '${request.params.name}' executed successfully in ${duration}ms.`);
-        const response = { isError: false, content: [] };
-        if (tool.outputSchema) {
-          if (!result.structuredContent) {
-            throw new Error(`Tool ${request.params.name} has an output schema but no structured content was provided.`);
-          }
-          const outputValidation = tool.outputSchema.validate?.(result.structuredContent ?? {});
-          if (outputValidation && !outputValidation.success) {
-            this.logger.warn(`CallTool: Invalid structured content for '${request.params.name}'`, {
-              errors: outputValidation.error
-            });
-            throw new Error(
-              `Invalid structured content for tool ${request.params.name}: ${JSON.stringify(outputValidation.error)}`
-            );
-          }
-          response.structuredContent = result.structuredContent;
-        }
-        if (result.content) {
-          response.content = result.content;
-        } else if (response.structuredContent) {
-          response.content = [{ type: "text", text: JSON.stringify(response.structuredContent) }];
-        } else {
-          response.content = [
-            {
-              type: "text",
-              text: typeof result === "string" ? result : JSON.stringify(result)
-            }
-          ];
-        }
-        return response;
-      } catch (error) {
-        const duration = Date.now() - startTime;
-        if (error instanceof zod.z.ZodError) {
-          this.logger.warn("Invalid tool arguments", {
-            tool: request.params.name,
-            errors: error.errors,
-            duration: `${duration}ms`
-          });
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Invalid arguments: ${error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ")}`
-              }
-            ],
-            isError: true
-          };
-        }
-        this.logger.error(`Tool execution failed: ${request.params.name}`, { error });
-        return {
-          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
-          isError: true
-        };
-      }
-    });
-  }
-  /**
-   * 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 {};
-    });
-  }
-  /**
-   * Register the ListPrompts handler.
-   */
-  registerListPromptsHandler() {
-    if (this.listPromptsHandlerIsRegistered) {
-      return;
-    }
-    this.listPromptsHandlerIsRegistered = true;
-    const capturedPromptOptions = this.promptOptions;
-    if (!capturedPromptOptions?.listPrompts) {
-      this.logger.warn("ListPrompts capability not supported by server configuration.");
-      return;
-    }
-    this.server.setRequestHandler(types_js.ListPromptsRequestSchema, async () => {
-      this.logger.debug("Handling ListPrompts request");
-      if (this.definedPrompts) {
-        return {
-          prompts: this.definedPrompts?.map((p) => ({ ...p, version: p.version ?? void 0 }))
-        };
-      } else {
-        try {
-          const prompts = await capturedPromptOptions.listPrompts();
-          for (const prompt of prompts) {
-            types_js.PromptSchema.parse(prompt);
-          }
-          this.definedPrompts = prompts;
-          this.logger.debug(`Fetched and cached ${this.definedPrompts.length} prompts.`);
-          return {
-            prompts: this.definedPrompts?.map((p) => ({ ...p, version: p.version ?? void 0 }))
-          };
-        } catch (error) {
-          this.logger.error("Error fetching prompts via listPrompts():", {
-            error: error instanceof Error ? error.message : String(error)
-          });
-          throw error;
-        }
-      }
-    });
-  }
-  /**
-   * Register the GetPrompt handler.
-   */
-  registerGetPromptHandler({
-    getPromptMessagesCallback
-  }) {
-    if (this.getPromptHandlerIsRegistered) return;
-    this.getPromptHandlerIsRegistered = true;
-    this.server.setRequestHandler(
-      types_js.GetPromptRequestSchema,
-      async (request) => {
-        const startTime = Date.now();
-        const { name, version, arguments: args } = request.params;
-        if (!this.definedPrompts) {
-          const prompts = await this.promptOptions?.listPrompts?.();
-          if (!prompts) throw new Error("Failed to load prompts");
-          this.definedPrompts = prompts;
-        }
-        let prompt;
-        if (version) {
-          prompt = this.definedPrompts?.find((p) => p.name === name && p.version === version);
-        } else {
-          prompt = this.definedPrompts?.find((p) => p.name === name);
-        }
-        if (!prompt) throw new Error(`Prompt "${name}"${version ? ` (version ${version})` : ""} not found`);
-        if (prompt.arguments) {
-          for (const arg of prompt.arguments) {
-            if (arg.required && (args?.[arg.name] === void 0 || args?.[arg.name] === null)) {
-              throw new Error(`Missing required argument: ${arg.name}`);
-            }
-          }
-        }
-        try {
-          let messages = [];
-          if (getPromptMessagesCallback) {
-            messages = await getPromptMessagesCallback({ name, version, args });
-          }
-          const duration = Date.now() - startTime;
-          this.logger.info(
-            `Prompt '${name}'${version ? ` (version ${version})` : ""} retrieved successfully in ${duration}ms.`
-          );
-          return { prompt, messages };
-        } catch (error) {
-          const duration = Date.now() - startTime;
-          this.logger.error(`Failed to get content for prompt '${name}' in ${duration}ms`, { error });
-          throw error;
-        }
-      }
-    );
-  }
   /**
    * Start the MCP server using stdio transport (for Windsurf integration).
    */
@@ -2208,11 +2208,17 @@ var MCPServer = class extends mcp.MCPServerBase {
                   `startHTTP: Streamable HTTP transport closed for session ${closedSessionId}, removing from map.`
                 );
                 this.streamableHTTPTransports.delete(closedSessionId);
+                if (this.httpServerInstances.has(closedSessionId)) {
+                  this.httpServerInstances.delete(closedSessionId);
+                  this.logger.debug(`startHTTP: Cleaned up server instance for closed session ${closedSessionId}`);
+                }
               }
             };
-            await this.server.connect(transport);
+            const sessionServerInstance = this.createServerInstance();
+            await sessionServerInstance.connect(transport);
             if (transport.sessionId) {
               this.streamableHTTPTransports.set(transport.sessionId, transport);
+              this.httpServerInstances.set(transport.sessionId, sessionServerInstance);
               this.logger.debug(
                 `startHTTP: Streamable HTTP session initialized and stored with ID: ${transport.sessionId}`
               );
@@ -2354,13 +2360,6 @@ var MCPServer = class extends mcp.MCPServerBase {
    * Close the MCP server and all its connections
    */
   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?.();
@@ -2382,6 +2381,12 @@ var MCPServer = class extends mcp.MCPServerBase {
         }
         this.streamableHTTPTransports.clear();
       }
+      if (this.httpServerInstances) {
+        for (const serverInstance of this.httpServerInstances.values()) {
+          await serverInstance.close?.();
+        }
+        this.httpServerInstances.clear();
+      }
       await this.server.close();
       this.logger.info("MCP server closed.");
     } catch (error$1) {