@mastra/mcp 1.1.0 → 1.2.0

package/dist/index.cjs

@@ -5,7 +5,6 @@ var $RefParser = require('@apidevtools/json-schema-ref-parser');
 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 = require('@modelcontextprotocol/sdk/client/index.js');
 var sse_js = require('@modelcontextprotocol/sdk/client/sse.js');
 var stdio_js = require('@modelcontextprotocol/sdk/client/stdio.js');
@@ -13,14 +12,13 @@ var streamableHttp_js = require('@modelcontextprotocol/sdk/client/streamableHttp
 var protocol_js = require('@modelcontextprotocol/sdk/shared/protocol.js');
 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 zodFromJsonSchemaV3 = require('zod-from-json-schema-v3');
 var equal = require('fast-deep-equal');
 var uuid = require('uuid');
 var crypto$1 = require('crypto');
 var mcp = require('@mastra/core/mcp');
 var requestContext = require('@mastra/core/request-context');
+var schema = require('@mastra/core/schema');
+var utils = require('@mastra/core/utils');
 var index_js$1 = require('@modelcontextprotocol/sdk/server/index.js');
 var sse_js$1 = require('@modelcontextprotocol/sdk/server/sse.js');
 var stdio_js$1 = require('@modelcontextprotocol/sdk/server/stdio.js');
@@ -499,18 +497,10 @@ var InternalMastraMCPClient = class extends base.MastraBase {
   }
   setupLogging() {
     if (this.enableServerLogs) {
-      this.client.setNotificationHandler(
-        zod.z.object({
-          method: zod.z.literal("notifications/message"),
-          params: zod.z.object({
-            level: zod.z.string()
-          }).passthrough()
-        }),
-        (notification) => {
-          const { level, ...params } = notification.params;
-          this.log(level, "[MCP SERVER LOG]", params);
-        }
-      );
+      this.client.setNotificationHandler(types_js.LoggingMessageNotificationSchema, (notification) => {
+        const { level, ...params } = notification.params;
+        this.log(level, "[MCP SERVER LOG]", params);
+      });
     }
   }
   /**
@@ -576,7 +566,9 @@ var InternalMastraMCPClient = class extends base.MastraBase {
       this.transport = new stdio_js.StdioClientTransport({
         command,
         args: this.serverConfig.args,
-        env: { ...stdio_js.getDefaultEnvironment(), ...this.serverConfig.env || {} }
+        env: { ...stdio_js.getDefaultEnvironment(), ...this.serverConfig.env || {} },
+        stderr: this.serverConfig.stderr,
+        cwd: this.serverConfig.cwd
       });
       await this.client.connect(this.transport, { timeout: this.serverConfig.timeout ?? this.timeout });
       this.log("debug", `Successfully connected to MCP server via Stdio`);
@@ -795,13 +787,13 @@ var InternalMastraMCPClient = class extends base.MastraBase {
   }
   async subscribeResource(uri) {
     this.log("debug", `Subscribing to resource on MCP server: ${uri}`);
-    return await this.client.request({ method: "resources/subscribe", params: { uri } }, zod.z.object({}), {
+    return await this.client.request({ method: "resources/subscribe", params: { uri } }, types_js.EmptyResultSchema, {
       timeout: this.timeout
     });
   }
   async unsubscribeResource(uri) {
     this.log("debug", `Unsubscribing from resource on MCP server: ${uri}`);
-    return await this.client.request({ method: "resources/unsubscribe", params: { uri } }, zod.z.object({}), {
+    return await this.client.request({ method: "resources/unsubscribe", params: { uri } }, types_js.EmptyResultSchema, {
       timeout: this.timeout
     });
   }
@@ -874,17 +866,9 @@ var InternalMastraMCPClient = class extends base.MastraBase {
     });
   }
   async convertInputSchema(inputSchema) {
-    if (utils.isZodType(inputSchema)) {
-      return inputSchema;
-    }
     try {
       await $RefParser__default.default.dereference(inputSchema);
-      const jsonSchemaToConvert = "jsonSchema" in inputSchema ? inputSchema.jsonSchema : inputSchema;
-      if ("toJSONSchema" in zod.z) {
-        return zodFromJsonSchema.convertJsonSchemaToZod(jsonSchemaToConvert);
-      } else {
-        return zodFromJsonSchemaV3.convertJsonSchemaToZod(jsonSchemaToConvert);
-      }
+      return "jsonSchema" in inputSchema ? inputSchema.jsonSchema : inputSchema;
     } catch (error$1) {
       let errorDetails;
       if (error$1 instanceof Error) {
@@ -896,7 +880,7 @@ var InternalMastraMCPClient = class extends base.MastraBase {
           errorDetails = String(error$1);
         }
       }
-      this.log("error", "Failed to convert JSON schema to Zod schema using zodFromJsonSchema", {
+      this.log("error", "Failed to dereference JSON schema", {
         error: errorDetails,
         originalJsonSchema: inputSchema
       });
@@ -908,46 +892,11 @@ var InternalMastraMCPClient = class extends base.MastraBase {
       });
     }
   }
-  /**
-   * Recursively applies `.passthrough()` to all ZodObject schemas so that
-   * unknown keys returned by an MCP server are preserved instead of being
-   * silently stripped by Zod's default "strip" mode.
-   */
-  applyPassthrough(schema) {
-    if (schema instanceof zod.z.ZodObject) {
-      const shape = schema.shape;
-      const newShape = {};
-      for (const key of Object.keys(shape)) {
-        newShape[key] = this.applyPassthrough(shape[key]);
-      }
-      return zod.z.object(newShape).passthrough();
-    }
-    if (schema instanceof zod.z.ZodArray) {
-      return zod.z.array(this.applyPassthrough(schema.element));
-    }
-    if (schema instanceof zod.z.ZodOptional) {
-      return this.applyPassthrough(schema.unwrap()).optional();
-    }
-    if (schema instanceof zod.z.ZodNullable) {
-      return this.applyPassthrough(schema.unwrap()).nullable();
-    }
-    return schema;
-  }
   async convertOutputSchema(outputSchema) {
     if (!outputSchema) return;
-    if (utils.isZodType(outputSchema)) {
-      return outputSchema;
-    }
     try {
       await $RefParser__default.default.dereference(outputSchema);
-      const jsonSchemaToConvert = "jsonSchema" in outputSchema ? outputSchema.jsonSchema : outputSchema;
-      let zodSchema;
-      if ("toJSONSchema" in zod.z) {
-        zodSchema = zodFromJsonSchema.convertJsonSchemaToZod(jsonSchemaToConvert);
-      } else {
-        zodSchema = zodFromJsonSchemaV3.convertJsonSchemaToZod(jsonSchemaToConvert);
-      }
-      return this.applyPassthrough(zodSchema);
+      return "jsonSchema" in outputSchema ? outputSchema.jsonSchema : outputSchema;
     } catch (error$1) {
       let errorDetails;
       if (error$1 instanceof Error) {
@@ -959,7 +908,7 @@ var InternalMastraMCPClient = class extends base.MastraBase {
           errorDetails = String(error$1);
         }
       }
-      this.log("error", "Failed to convert JSON schema to Zod schema using zodFromJsonSchema", {
+      this.log("error", "Failed to dereference JSON schema", {
         error: errorDetails,
         originalJsonSchema: outputSchema
       });
@@ -983,6 +932,10 @@ var InternalMastraMCPClient = class extends base.MastraBase {
           description: tool.description || "",
           inputSchema: await this.convertInputSchema(tool.inputSchema),
           outputSchema: await this.convertOutputSchema(tool.outputSchema),
+          mcpMetadata: {
+            serverName: this.name,
+            serverVersion: this.client.getServerVersion()?.version
+          },
           execute: async (input, context) => {
             const operationContext = context?.requestContext ?? null;
             return this.operationContextStore.run(operationContext, async () => {
@@ -997,7 +950,8 @@ var InternalMastraMCPClient = class extends base.MastraBase {
                   },
                   types_js.CallToolResultSchema,
                   {
-                    timeout: this.timeout
+                    timeout: this.timeout,
+                    signal: context?.abortSignal
                   }
                 );
                 this.log("debug", `Tool executed successfully: ${tool.name}`);
@@ -2747,10 +2701,10 @@ var MCPServer = class extends mcp.MCPServerBase {
           const toolSpec = {
             name: tool.id || "unknown",
             description: tool.description,
-            inputSchema: tool.parameters.jsonSchema
+            inputSchema: this.convertSchema(tool.parameters)
           };
           if (tool.outputSchema) {
-            toolSpec.outputSchema = tool.outputSchema.jsonSchema;
+            toolSpec.outputSchema = this.convertSchema(tool.outputSchema);
           }
           if (tool.mcp?.annotations) {
             toolSpec.annotations = tool.mcp.annotations;
@@ -2862,17 +2816,18 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
         return response;
       } catch (error$1) {
         const duration = Date.now() - startTime;
-        if (error$1 instanceof zod.z.ZodError) {
+        if (error$1 instanceof Error && "issues" in error$1 && Array.isArray(error$1.issues)) {
+          const issues = error$1.issues;
           this.logger.warn("Invalid tool arguments", {
             tool: request.params.name,
-            errors: error$1.errors,
+            errors: issues,
             duration: `${duration}ms`
           });
           return {
             content: [
               {
                 type: "text",
-                text: `Invalid arguments: ${error$1.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ")}`
+                text: `Invalid arguments: ${issues.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ")}`
               }
             ],
             isError: true
@@ -3105,12 +3060,18 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
       const agentToolDefinition = tools.createTool({
         id: agentToolName,
         description: `Ask agent '${agent.name}' a question. Agent description: ${agentDescription}`,
-        inputSchema: zod.z.object({
-          message: zod.z.string().describe("The question or input for the agent.")
-        }),
+        inputSchema: {
+          type: "object",
+          properties: {
+            message: { type: "string", description: "The question or input for the agent." }
+          },
+          required: ["message"],
+          additionalProperties: false
+        },
         execute: async (inputData, context) => {
+          const { message } = inputData;
           this.logger.debug(
-            `Executing agent tool '${agentToolName}' for agent '${agent.name}' with message: "${inputData.message}"`
+            `Executing agent tool '${agentToolName}' for agent '${agent.name}' with message: "${message}"`
           );
           try {
             const proxiedContext = context?.requestContext || new requestContext.RequestContext();
@@ -3119,7 +3080,7 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
                 proxiedContext.set(key, value);
               });
             }
-            const response = await agent.generate(inputData.message, {
+            const response = await agent.generate(message, {
               ...context ?? {},
               requestContext: proxiedContext
             });
@@ -3972,6 +3933,12 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
       remotes: this.remotes
     };
   }
+  convertSchema(schema$1) {
+    if (schema.isStandardSchemaWithJSON(schema$1)) {
+      return schema.standardSchemaToJSONSchema(schema$1);
+    }
+    return schema$1?.jsonSchema || schema$1;
+  }
   /**
    * Gets a list of all tools provided by this MCP server with their schemas.
    *
@@ -3996,8 +3963,8 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
         id: toolId,
         name: tool.id || toolId,
         description: tool.description,
-        inputSchema: tool.parameters?.jsonSchema || tool.parameters,
-        outputSchema: tool.outputSchema?.jsonSchema || tool.outputSchema,
+        inputSchema: this.convertSchema(tool.parameters),
+        outputSchema: this.convertSchema(tool.parameters),
         toolType: tool.mcp?.toolType
       }))
     };
@@ -4030,8 +3997,8 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
     return {
       name: tool.id || toolId,
       description: tool.description,
-      inputSchema: tool.parameters?.jsonSchema || tool.parameters,
-      outputSchema: tool.outputSchema?.jsonSchema || tool.outputSchema,
+      inputSchema: this.convertSchema(tool.parameters),
+      outputSchema: this.convertSchema(tool.outputSchema),
       toolType: tool.mcp?.toolType
     };
   }
@@ -4066,23 +4033,29 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
         throw new Error(`Unknown tool: ${toolId}`);
       }
       this.logger.debug(`ExecuteTool: Invoking '${toolId}' with arguments:`, args);
-      if (tool.parameters instanceof zod.z.ZodType && typeof tool.parameters.safeParse === "function") {
-        const validation = tool.parameters.safeParse(args ?? {});
-        if (!validation.success) {
-          const errorMessages = validation.error.errors.map((e) => `- ${e.path?.join(".") || "root"}: ${e.message}`).join("\n");
+      const paramsSchema = tool.parameters;
+      const validation = typeof paramsSchema?.validate === "function" ? paramsSchema.validate(args ?? {}) : typeof paramsSchema?.safeParse === "function" ? paramsSchema.safeParse(args ?? {}) : null;
+      if (validation) {
+        const success = typeof validation.success === "boolean" ? validation.success : !validation.issues?.length;
+        if (!success) {
+          const issues = validation.error?.issues ?? validation.error?.errors ?? validation.issues ?? [];
+          const errorMessages = issues.map(
+            (e) => `- ${e.path?.join(".") || "root"}: ${e.message}`
+          ).join("\n");
+          const validationErrors = validation.error?.format?.() ?? validation.error ?? validation.issues;
           this.logger.warn(`ExecuteTool: Invalid tool arguments for '${toolId}': ${errorMessages}`, {
-            errors: validation.error.format()
+            errors: validationErrors
           });
           return {
             error: true,
             message: `Tool validation failed. Please fix the following errors and try again:
-${errorMessages}
+${errorMessages || "Validation failed"}
 
 Provided arguments: ${JSON.stringify(args, null, 2)}`,
-            validationErrors: validation.error.format()
+            validationErrors
           };
         }
-        validatedArgs = validation.data;
+        validatedArgs = validation.data ?? validation.value ?? args;
       } else {
         this.logger.debug(
           `ExecuteTool: Tool '${toolId}' parameters is not a Zod schema with safeParse or is undefined. Skipping validation.`