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

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,7 +23,6 @@ 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 }; }
 
@@ -484,22 +483,57 @@ var InternalMastraMCPClient = class extends base.MastraBase {
     }
     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 +547,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;
@@ -935,6 +970,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 +1140,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 +1159,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}`
@@ -1336,8 +1534,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 +1558,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 +1598,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}'`);
@@ -1445,11 +1645,17 @@ var MCPServer = class extends mcp.MCPServerBase {
     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
-        }))
+        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;
+        })
       };
     });
   }
@@ -1472,7 +1678,6 @@ var MCPServer = class extends mcp.MCPServerBase {
             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}'`, {
@@ -1491,17 +1696,38 @@ var MCPServer = class extends mcp.MCPServerBase {
           };
         }
         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.`);
-        return {
-          content: [
+        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)
             }
-          ],
-          isError: false
-        };
+          ];
+        }
+        return response;
       } catch (error) {
         const duration = Date.now() - startTime;
         if (error instanceof zod.z.ZodError) {
@@ -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) {
@@ -2084,13 +2310,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 +2330,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(
@@ -2214,6 +2440,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 +2461,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
     };
   }