@mastra/mcp 0.10.5-alpha.0 → 0.10.5-alpha.2

package/dist/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var base = require('@mastra/core/base');
+var error = require('@mastra/core/error');
 var tools = require('@mastra/core/tools');
 var utils = require('@mastra/core/utils');
 var index_js$1 = require('@modelcontextprotocol/sdk/client/index.js');
@@ -12,7 +13,6 @@ var types_js = require('@modelcontextprotocol/sdk/types.js');
 var exitHook = require('exit-hook');
 var zod = require('zod');
 var zodFromJsonSchema = require('zod-from-json-schema');
-var error = require('@mastra/core/error');
 var equal = require('fast-deep-equal');
 var uuid = require('uuid');
 var crypto$1 = require('crypto');
@@ -23,13 +23,29 @@ var index_js = require('@modelcontextprotocol/sdk/server/index.js');
 var sse_js = require('@modelcontextprotocol/sdk/server/sse.js');
 var stdio_js = require('@modelcontextprotocol/sdk/server/stdio.js');
 var streamableHttp_js = require('@modelcontextprotocol/sdk/server/streamableHttp.js');
-var streaming = require('hono/streaming');
 
 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;
@@ -212,6 +228,7 @@ var InternalMastraMCPClient = class extends base.MastraBase {
   currentOperationContext = null;
   resources;
   prompts;
+  elicitation;
   constructor({
     name,
     version = "1.0.0",
@@ -225,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
@@ -478,28 +497,70 @@ 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;
     }
     try {
       return zodFromJsonSchema.convertJsonSchemaToZod(inputSchema);
-    } catch (error) {
+    } catch (error$1) {
       let errorDetails;
-      if (error instanceof Error) {
-        errorDetails = error.stack;
+      if (error$1 instanceof Error) {
+        errorDetails = error$1.stack;
       } else {
         try {
-          errorDetails = JSON.stringify(error);
+          errorDetails = JSON.stringify(error$1);
         } catch {
-          errorDetails = String(error);
+          errorDetails = String(error$1);
         }
       }
       this.log("error", "Failed to convert JSON schema to Zod schema using zodFromJsonSchema", {
         error: errorDetails,
         originalJsonSchema: inputSchema
       });
-      throw new Error(errorDetails);
+      throw new error.MastraError({
+        id: "MCP_TOOL_INPUT_SCHEMA_CONVERSION_FAILED",
+        domain: error.ErrorDomain.MCP,
+        category: error.ErrorCategory.USER,
+        details: { error: errorDetails ?? "Unknown error" }
+      });
+    }
+  }
+  convertOutputSchema(outputSchema) {
+    if (!outputSchema) return;
+    if (utils.isZodType(outputSchema)) {
+      return outputSchema;
+    }
+    try {
+      return zodFromJsonSchema.convertJsonSchemaToZod(outputSchema);
+    } catch (error$1) {
+      let errorDetails;
+      if (error$1 instanceof Error) {
+        errorDetails = error$1.stack;
+      } else {
+        try {
+          errorDetails = JSON.stringify(error$1);
+        } catch {
+          errorDetails = String(error$1);
+        }
+      }
+      this.log("error", "Failed to convert JSON schema to Zod schema using zodFromJsonSchema", {
+        error: errorDetails,
+        originalJsonSchema: outputSchema
+      });
+      throw new error.MastraError({
+        id: "MCP_TOOL_OUTPUT_SCHEMA_CONVERSION_FAILED",
+        domain: error.ErrorDomain.MCP,
+        category: error.ErrorCategory.USER,
+        details: { error: errorDetails ?? "Unknown error" }
+      });
     }
   }
   async tools() {
@@ -513,6 +574,7 @@ var InternalMastraMCPClient = class extends base.MastraBase {
           id: `${this.name}_${tool.name}`,
           description: tool.description || "",
           inputSchema: this.convertInputSchema(tool.inputSchema),
+          outputSchema: this.convertOutputSchema(tool.outputSchema),
           execute: async ({ context, runtimeContext }) => {
             const previousContext = this.currentOperationContext;
             this.currentOperationContext = runtimeContext || null;
@@ -606,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 {
@@ -935,6 +1017,165 @@ var MCPConfiguration = class extends MCPClient {
     );
   }
 };
+
+// ../../node_modules/.pnpm/hono@4.8.1/node_modules/hono/dist/utils/stream.js
+var StreamingApi = class {
+  writer;
+  encoder;
+  writable;
+  abortSubscribers = [];
+  responseReadable;
+  aborted = false;
+  closed = false;
+  constructor(writable, _readable) {
+    this.writable = writable;
+    this.writer = writable.getWriter();
+    this.encoder = new TextEncoder();
+    const reader = _readable.getReader();
+    this.abortSubscribers.push(async () => {
+      await reader.cancel();
+    });
+    this.responseReadable = new ReadableStream({
+      async pull(controller) {
+        const { done, value } = await reader.read();
+        done ? controller.close() : controller.enqueue(value);
+      },
+      cancel: () => {
+        this.abort();
+      }
+    });
+  }
+  async write(input) {
+    try {
+      if (typeof input === "string") {
+        input = this.encoder.encode(input);
+      }
+      await this.writer.write(input);
+    } catch {
+    }
+    return this;
+  }
+  async writeln(input) {
+    await this.write(input + "\n");
+    return this;
+  }
+  sleep(ms) {
+    return new Promise((res) => setTimeout(res, ms));
+  }
+  async close() {
+    try {
+      await this.writer.close();
+    } catch {
+    }
+    this.closed = true;
+  }
+  async pipe(body) {
+    this.writer.releaseLock();
+    await body.pipeTo(this.writable, { preventClose: true });
+    this.writer = this.writable.getWriter();
+  }
+  onAbort(listener) {
+    this.abortSubscribers.push(listener);
+  }
+  abort() {
+    if (!this.aborted) {
+      this.aborted = true;
+      this.abortSubscribers.forEach((subscriber) => subscriber());
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.8.1/node_modules/hono/dist/helper/streaming/utils.js
+var isOldBunVersion = () => {
+  const version = typeof Bun !== "undefined" ? Bun.version : void 0;
+  if (version === void 0) {
+    return false;
+  }
+  const result = version.startsWith("1.1") || version.startsWith("1.0") || version.startsWith("0.");
+  isOldBunVersion = () => result;
+  return result;
+};
+
+// ../../node_modules/.pnpm/hono@4.8.1/node_modules/hono/dist/utils/html.js
+var HtmlEscapedCallbackPhase = {
+  Stringify: 1};
+var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
+  if (typeof str === "object" && !(str instanceof String)) {
+    if (!(str instanceof Promise)) {
+      str = str.toString();
+    }
+    if (str instanceof Promise) {
+      str = await str;
+    }
+  }
+  const callbacks = str.callbacks;
+  if (!callbacks?.length) {
+    return Promise.resolve(str);
+  }
+  if (buffer) {
+    buffer[0] += str;
+  } else {
+    buffer = [str];
+  }
+  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then(
+    (res) => Promise.all(
+      res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))
+    ).then(() => buffer[0])
+  );
+  {
+    return resStr;
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.8.1/node_modules/hono/dist/helper/streaming/sse.js
+var SSEStreamingApi = class extends StreamingApi {
+  constructor(writable, readable) {
+    super(writable, readable);
+  }
+  async writeSSE(message) {
+    const data = await resolveCallback(message.data, HtmlEscapedCallbackPhase.Stringify, false, {});
+    const dataLines = data.split("\n").map((line) => {
+      return `data: ${line}`;
+    }).join("\n");
+    const sseData = [
+      message.event && `event: ${message.event}`,
+      dataLines,
+      message.id && `id: ${message.id}`,
+      message.retry && `retry: ${message.retry}`
+    ].filter(Boolean).join("\n") + "\n\n";
+    await this.write(sseData);
+  }
+};
+var run = async (stream2, cb, onError) => {
+  try {
+    await cb(stream2);
+  } catch (e) {
+    {
+      console.error(e);
+    }
+  } finally {
+    stream2.close();
+  }
+};
+var contextStash = /* @__PURE__ */ new WeakMap();
+var streamSSE = (c, cb, onError) => {
+  const { readable, writable } = new TransformStream();
+  const stream2 = new SSEStreamingApi(writable, readable);
+  if (isOldBunVersion()) {
+    c.req.raw.signal.addEventListener("abort", () => {
+      if (!stream2.closed) {
+        stream2.abort();
+      }
+    });
+  }
+  contextStash.set(stream2.responseReadable, c);
+  c.header("Transfer-Encoding", "chunked");
+  c.header("Content-Type", "text/event-stream");
+  c.header("Cache-Control", "no-cache");
+  c.header("Connection", "keep-alive");
+  run(stream2, cb);
+  return c.newResponse(stream2.responseReadable);
+};
 var MAXIMUM_MESSAGE_SIZE = 4 * 1024 * 1024;
 var SSETransport = class {
   messageUrl;
@@ -946,9 +1187,9 @@ var SSETransport = class {
   /**
    * Creates a new SSETransport, which will direct the MPC client to POST messages to messageUrl
    */
-  constructor(messageUrl, stream) {
+  constructor(messageUrl, stream2) {
     this.messageUrl = messageUrl;
-    this.stream = stream;
+    this.stream = stream2;
     this._sessionId = crypto.randomUUID();
     this.stream.onAbort(() => {
       void this.close();
@@ -965,6 +1206,10 @@ var SSETransport = class {
     if (this.stream.closed) {
       throw new Error("SSE transport already closed!");
     }
+    await this.stream.writeSSE({
+      event: "ping",
+      data: ""
+    });
     await this.stream.writeSSE({
       event: "endpoint",
       data: `${this.messageUrl}?sessionId=${this.sessionId}`
@@ -1138,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;
@@ -1155,6 +1393,7 @@ var MCPServer = class extends mcp.MCPServerBase {
   subscriptions = /* @__PURE__ */ new Set();
   resources;
   prompts;
+  elicitation;
   /**
    * Get the current stdio transport.
    */
@@ -1189,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 };
@@ -1202,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,
@@ -1237,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 = {};
@@ -1336,8 +1896,8 @@ var MCPServer = class extends mcp.MCPServerBase {
             context
           );
           try {
-            const run = workflow.createRun({ runId: runtimeContext?.get("runId") });
-            const response = await run.start({ inputData: context, runtimeContext });
+            const run2 = workflow.createRun({ runId: runtimeContext?.get("runId") });
+            const response = await run2.start({ inputData: context, runtimeContext });
             return response;
           } catch (error) {
             this.logger.error(
@@ -1360,6 +1920,7 @@ var MCPServer = class extends mcp.MCPServerBase {
         name: workflowToolName,
         description: coreTool.description,
         parameters: coreTool.parameters,
+        outputSchema: coreTool.outputSchema,
         execute: coreTool.execute,
         toolType: "workflow"
       };
@@ -1399,6 +1960,7 @@ var MCPServer = class extends mcp.MCPServerBase {
         name: toolName,
         description: coreTool.description,
         parameters: coreTool.parameters,
+        outputSchema: coreTool.outputSchema,
         execute: coreTool.execute
       };
       this.logger.info(`Registered explicit tool: '${toolName}'`);
@@ -1434,342 +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) => ({
-          name: tool.name,
-          description: tool.description,
-          inputSchema: tool.parameters.jsonSchema
-        }))
-      };
-    });
-  }
-  /**
-   * 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
-          };
-        }
-        this.logger.debug(`CallTool: Invoking '${request.params.name}' with arguments:`, request.params.arguments);
-        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: "" });
-        const duration = Date.now() - startTime;
-        this.logger.info(`Tool '${request.params.name}' executed successfully in ${duration}ms.`);
-        return {
-          content: [
-            {
-              type: "text",
-              text: typeof result === "string" ? result : JSON.stringify(result)
-            }
-          ],
-          isError: false
-        };
-      } 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).
    */
@@ -1855,10 +2081,10 @@ var MCPServer = class extends mcp.MCPServerBase {
   async startHonoSSE({ url, ssePath, messagePath, context }) {
     try {
       if (url.pathname === ssePath) {
-        return streaming.streamSSE(context, async (stream) => {
+        return streamSSE(context, async (stream2) => {
           await this.connectHonoSSE({
             messagePath,
-            stream
+            stream: stream2
           });
         });
       } else if (url.pathname === messagePath) {
@@ -1982,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}`
               );
@@ -2084,13 +2316,13 @@ var MCPServer = class extends mcp.MCPServerBase {
       throw mastraError;
     }
   }
-  async connectHonoSSE({ messagePath, stream }) {
+  async connectHonoSSE({ messagePath, stream: stream2 }) {
     this.logger.debug("Received SSE connection");
-    const sseTransport = new SSETransport(messagePath, stream);
+    const sseTransport = new SSETransport(messagePath, stream2);
     const sessionId = sseTransport.sessionId;
     this.logger.debug("SSE Transport created with sessionId:", { sessionId });
     this.sseHonoTransports.set(sessionId, sseTransport);
-    stream.onAbort(() => {
+    stream2.onAbort(() => {
       this.logger.debug("SSE Transport aborted with sessionId:", { sessionId });
       this.sseHonoTransports.delete(sessionId);
     });
@@ -2104,8 +2336,8 @@ var MCPServer = class extends mcp.MCPServerBase {
       while (true) {
         const sessionIds = Array.from(this.sseHonoTransports.keys() || []);
         this.logger.debug("Active Hono SSE sessions:", { sessionIds });
-        await stream.write(":keep-alive\n\n");
-        await stream.sleep(6e4);
+        await stream2.write(":keep-alive\n\n");
+        await stream2.sleep(6e4);
       }
     } catch (e) {
       const mastraError = new error.MastraError(
@@ -2128,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?.();
@@ -2156,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) {
@@ -2214,6 +2445,7 @@ var MCPServer = class extends mcp.MCPServerBase {
         name: tool.name,
         description: tool.description,
         inputSchema: tool.parameters?.jsonSchema || tool.parameters,
+        outputSchema: tool.outputSchema?.jsonSchema || tool.outputSchema,
         toolType: tool.toolType
       }))
     };
@@ -2234,6 +2466,7 @@ var MCPServer = class extends mcp.MCPServerBase {
       name: tool.name,
       description: tool.description,
       inputSchema: tool.parameters?.jsonSchema || tool.parameters,
+      outputSchema: tool.outputSchema?.jsonSchema || tool.outputSchema,
       toolType: tool.toolType
     };
   }