@mastra/mcp 0.10.4 → 0.10.5-alpha.1

package/dist/index.js

@@ -1,4 +1,5 @@
 import { MastraBase } from '@mastra/core/base';
+import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
 import { createTool as createTool$1 } from '@mastra/core/tools';
 import { isZodType } from '@mastra/core/utils';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
@@ -20,7 +21,6 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { streamSSE } from 'hono/streaming';
 
 // src/client/client.ts
 var PromptClientActions = class {
@@ -492,7 +492,42 @@ var InternalMastraMCPClient = class extends MastraBase {
         error: errorDetails,
         originalJsonSchema: inputSchema
       });
-      throw new Error(errorDetails);
+      throw new MastraError({
+        id: "MCP_TOOL_INPUT_SCHEMA_CONVERSION_FAILED",
+        domain: ErrorDomain.MCP,
+        category: ErrorCategory.USER,
+        details: { error: errorDetails ?? "Unknown error" }
+      });
+    }
+  }
+  convertOutputSchema(outputSchema) {
+    if (!outputSchema) return;
+    if (isZodType(outputSchema)) {
+      return outputSchema;
+    }
+    try {
+      return convertJsonSchemaToZod(outputSchema);
+    } catch (error) {
+      let errorDetails;
+      if (error instanceof Error) {
+        errorDetails = error.stack;
+      } else {
+        try {
+          errorDetails = JSON.stringify(error);
+        } catch {
+          errorDetails = String(error);
+        }
+      }
+      this.log("error", "Failed to convert JSON schema to Zod schema using zodFromJsonSchema", {
+        error: errorDetails,
+        originalJsonSchema: outputSchema
+      });
+      throw new MastraError({
+        id: "MCP_TOOL_OUTPUT_SCHEMA_CONVERSION_FAILED",
+        domain: ErrorDomain.MCP,
+        category: ErrorCategory.USER,
+        details: { error: errorDetails ?? "Unknown error" }
+      });
     }
   }
   async tools() {
@@ -506,6 +541,7 @@ var InternalMastraMCPClient = class extends 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;
@@ -609,7 +645,16 @@ To fix this you have three different options:
             const internalClient = await this.getConnectedClientForServer(serverName);
             allResources[serverName] = await internalClient.resources.list();
           } catch (error) {
-            this.logger.error(`Failed to list resources from server ${serverName}`, { error });
+            const mastraError = new MastraError({
+              id: "MCP_CLIENT_LIST_RESOURCES_FAILED",
+              domain: ErrorDomain.MCP,
+              category: ErrorCategory.THIRD_PARTY,
+              details: {
+                serverName
+              }
+            }, error);
+            this.logger.trackException(mastraError);
+            this.logger.error("Failed to list resources from server:", { error: mastraError.toString() });
           }
         }
         return allResources;
@@ -621,30 +666,97 @@ To fix this you have three different options:
             const internalClient = await this.getConnectedClientForServer(serverName);
             allTemplates[serverName] = await internalClient.resources.templates();
           } catch (error) {
-            this.logger.error(`Failed to list resource templates from server ${serverName}`, { error });
+            const mastraError = new MastraError({
+              id: "MCP_CLIENT_LIST_RESOURCE_TEMPLATES_FAILED",
+              domain: ErrorDomain.MCP,
+              category: ErrorCategory.THIRD_PARTY,
+              details: {
+                serverName
+              }
+            }, error);
+            this.logger.trackException(mastraError);
+            this.logger.error("Failed to list resource templates from server:", { error: mastraError.toString() });
           }
         }
         return allTemplates;
       },
       read: async (serverName, uri) => {
-        const internalClient = await this.getConnectedClientForServer(serverName);
-        return internalClient.resources.read(uri);
+        try {
+          const internalClient = await this.getConnectedClientForServer(serverName);
+          return internalClient.resources.read(uri);
+        } catch (error) {
+          throw new MastraError({
+            id: "MCP_CLIENT_READ_RESOURCE_FAILED",
+            domain: ErrorDomain.MCP,
+            category: ErrorCategory.THIRD_PARTY,
+            details: {
+              serverName,
+              uri
+            }
+          }, error);
+        }
       },
       subscribe: async (serverName, uri) => {
-        const internalClient = await this.getConnectedClientForServer(serverName);
-        return internalClient.resources.subscribe(uri);
+        try {
+          const internalClient = await this.getConnectedClientForServer(serverName);
+          return internalClient.resources.subscribe(uri);
+        } catch (error) {
+          throw new MastraError({
+            id: "MCP_CLIENT_SUBSCRIBE_RESOURCE_FAILED",
+            domain: ErrorDomain.MCP,
+            category: ErrorCategory.THIRD_PARTY,
+            details: {
+              serverName,
+              uri
+            }
+          }, error);
+        }
       },
       unsubscribe: async (serverName, uri) => {
-        const internalClient = await this.getConnectedClientForServer(serverName);
-        return internalClient.resources.unsubscribe(uri);
+        try {
+          const internalClient = await this.getConnectedClientForServer(serverName);
+          return internalClient.resources.unsubscribe(uri);
+        } catch (err) {
+          throw new MastraError({
+            id: "MCP_CLIENT_UNSUBSCRIBE_RESOURCE_FAILED",
+            domain: ErrorDomain.MCP,
+            category: ErrorCategory.THIRD_PARTY,
+            details: {
+              serverName,
+              uri
+            }
+          }, err);
+        }
       },
       onUpdated: async (serverName, handler) => {
-        const internalClient = await this.getConnectedClientForServer(serverName);
-        return internalClient.resources.onUpdated(handler);
+        try {
+          const internalClient = await this.getConnectedClientForServer(serverName);
+          return internalClient.resources.onUpdated(handler);
+        } catch (err) {
+          throw new MastraError({
+            id: "MCP_CLIENT_ON_UPDATED_RESOURCE_FAILED",
+            domain: ErrorDomain.MCP,
+            category: ErrorCategory.THIRD_PARTY,
+            details: {
+              serverName
+            }
+          }, err);
+        }
       },
       onListChanged: async (serverName, handler) => {
-        const internalClient = await this.getConnectedClientForServer(serverName);
-        return internalClient.resources.onListChanged(handler);
+        try {
+          const internalClient = await this.getConnectedClientForServer(serverName);
+          return internalClient.resources.onListChanged(handler);
+        } catch (err) {
+          throw new MastraError({
+            id: "MCP_CLIENT_ON_LIST_CHANGED_RESOURCE_FAILED",
+            domain: ErrorDomain.MCP,
+            category: ErrorCategory.THIRD_PARTY,
+            details: {
+              serverName
+            }
+          }, err);
+        }
       }
     };
   }
@@ -658,18 +770,50 @@ To fix this you have three different options:
             const internalClient = await this.getConnectedClientForServer(serverName);
             allPrompts[serverName] = await internalClient.prompts.list();
           } catch (error) {
-            this.logger.error(`Failed to list prompts from server ${serverName}`, { error });
+            const mastraError = new MastraError({
+              id: "MCP_CLIENT_LIST_PROMPTS_FAILED",
+              domain: ErrorDomain.MCP,
+              category: ErrorCategory.THIRD_PARTY,
+              details: {
+                serverName
+              }
+            }, error);
+            this.logger.trackException(mastraError);
+            this.logger.error("Failed to list prompts from server:", { error: mastraError.toString() });
           }
         }
         return allPrompts;
       },
       get: async ({ serverName, name, args, version }) => {
-        const internalClient = await this.getConnectedClientForServer(serverName);
-        return internalClient.prompts.get({ name, args, version });
+        try {
+          const internalClient = await this.getConnectedClientForServer(serverName);
+          return internalClient.prompts.get({ name, args, version });
+        } catch (error) {
+          throw new MastraError({
+            id: "MCP_CLIENT_GET_PROMPT_FAILED",
+            domain: ErrorDomain.MCP,
+            category: ErrorCategory.THIRD_PARTY,
+            details: {
+              serverName,
+              name
+            }
+          }, error);
+        }
       },
       onListChanged: async (serverName, handler) => {
-        const internalClient = await this.getConnectedClientForServer(serverName);
-        return internalClient.prompts.onListChanged(handler);
+        try {
+          const internalClient = await this.getConnectedClientForServer(serverName);
+          return internalClient.prompts.onListChanged(handler);
+        } catch (error) {
+          throw new MastraError({
+            id: "MCP_CLIENT_ON_LIST_CHANGED_PROMPT_FAILED",
+            domain: ErrorDomain.MCP,
+            category: ErrorCategory.THIRD_PARTY,
+            details: {
+              serverName
+            }
+          }, error);
+        }
       }
     };
   }
@@ -701,21 +845,37 @@ To fix this you have three different options:
   async getTools() {
     this.addToInstanceCache();
     const connectedTools = {};
-    await this.eachClientTools(async ({ serverName, tools }) => {
-      for (const [toolName, toolConfig] of Object.entries(tools)) {
-        connectedTools[`${serverName}_${toolName}`] = toolConfig;
-      }
-    });
+    try {
+      await this.eachClientTools(async ({ serverName, tools }) => {
+        for (const [toolName, toolConfig] of Object.entries(tools)) {
+          connectedTools[`${serverName}_${toolName}`] = toolConfig;
+        }
+      });
+    } catch (error) {
+      throw new MastraError({
+        id: "MCP_CLIENT_GET_TOOLS_FAILED",
+        domain: ErrorDomain.MCP,
+        category: ErrorCategory.THIRD_PARTY
+      }, error);
+    }
     return connectedTools;
   }
   async getToolsets() {
     this.addToInstanceCache();
     const connectedToolsets = {};
-    await this.eachClientTools(async ({ serverName, tools }) => {
-      if (tools) {
-        connectedToolsets[serverName] = tools;
-      }
-    });
+    try {
+      await this.eachClientTools(async ({ serverName, tools }) => {
+        if (tools) {
+          connectedToolsets[serverName] = tools;
+        }
+      });
+    } catch (error) {
+      throw new MastraError({
+        id: "MCP_CLIENT_GET_TOOLSETS_FAILED",
+        domain: ErrorDomain.MCP,
+        category: ErrorCategory.THIRD_PARTY
+      }, error);
+    }
     return connectedToolsets;
   }
   /**
@@ -762,13 +922,19 @@ To fix this you have three different options:
     try {
       await mcpClient.connect();
     } catch (e) {
+      const mastraError = new MastraError({
+        id: "MCP_CLIENT_CONNECT_FAILED",
+        domain: ErrorDomain.MCP,
+        category: ErrorCategory.THIRD_PARTY,
+        text: `Failed to connect to MCP server ${name}: ${e instanceof Error ? e.stack || e.message : String(e)}`,
+        details: {
+          name
+        }
+      }, e);
+      this.logger.trackException(mastraError);
+      this.logger.error("MCPClient errored connecting to MCP server:", { error: mastraError.toString() });
       this.mcpClientsById.delete(name);
-      this.logger.error(`MCPClient errored connecting to MCP server ${name}`, {
-        error: e instanceof Error ? e.message : String(e)
-      });
-      throw new Error(
-        `Failed to connect to MCP server ${name}: ${e instanceof Error ? e.stack || e.message : String(e)}`
-      );
+      throw mastraError;
     }
     this.logger.debug(`Connected to ${name} MCP server`);
     return mcpClient;
@@ -798,6 +964,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;
@@ -809,9 +1134,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();
@@ -828,6 +1153,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}`
@@ -882,8 +1211,6 @@ var SSETransport = class {
     });
   }
 };
-
-// src/server/promptActions.ts
 var ServerPromptActions = class {
   getLogger;
   getSdkServer;
@@ -903,15 +1230,23 @@ var ServerPromptActions = class {
     try {
       await this.getSdkServer().sendPromptListChanged();
     } catch (error) {
+      const mastraError = new MastraError(
+        {
+          id: "MCP_SERVER_PROMPT_LIST_CHANGED_NOTIFICATION_FAILED",
+          domain: ErrorDomain.MCP,
+          category: ErrorCategory.THIRD_PARTY,
+          text: "Failed to send prompt list changed notification"
+        },
+        error
+      );
       this.getLogger().error("Failed to send prompt list changed notification:", {
-        error: error instanceof Error ? error.message : String(error)
+        error: mastraError.toString()
       });
-      throw error;
+      this.getLogger().trackException(mastraError);
+      throw mastraError;
     }
   }
 };
-
-// src/server/resourceActions.ts
 var ServerResourceActions = class {
   getSubscriptions;
   getLogger;
@@ -935,8 +1270,23 @@ var ServerResourceActions = class {
       try {
         await this.getSdkServer().sendResourceUpdated({ uri });
       } catch (error) {
-        this.getLogger().error("Failed to send resource updated notification:", { error });
-        throw error;
+        const mastraError = new MastraError(
+          {
+            id: "MCP_SERVER_RESOURCE_UPDATED_NOTIFICATION_FAILED",
+            domain: ErrorDomain.MCP,
+            category: ErrorCategory.THIRD_PARTY,
+            text: "Failed to send resource updated notification",
+            details: {
+              uri
+            }
+          },
+          error
+        );
+        this.getLogger().trackException(mastraError);
+        this.getLogger().error("Failed to send resource updated notification:", {
+          error: mastraError.toString()
+        });
+        throw mastraError;
       }
     } else {
       this.getLogger().debug(`Resource ${uri} was updated, but no active subscriptions for it.`);
@@ -955,8 +1305,20 @@ var ServerResourceActions = class {
     try {
       await this.getSdkServer().sendResourceListChanged();
     } catch (error) {
-      this.getLogger().error("Failed to send resource list changed notification:", { error });
-      throw error;
+      const mastraError = new MastraError(
+        {
+          id: "MCP_SERVER_RESOURCE_LIST_CHANGED_NOTIFICATION_FAILED",
+          domain: ErrorDomain.MCP,
+          category: ErrorCategory.THIRD_PARTY,
+          text: "Failed to send resource list changed notification"
+        },
+        error
+      );
+      this.getLogger().trackException(mastraError);
+      this.getLogger().error("Failed to send resource list changed notification:", {
+        error: mastraError.toString()
+      });
+      throw mastraError;
     }
   }
 };
@@ -1166,8 +1528,8 @@ var MCPServer = class extends 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(
@@ -1190,6 +1552,7 @@ var MCPServer = class extends MCPServerBase {
         name: workflowToolName,
         description: coreTool.description,
         parameters: coreTool.parameters,
+        outputSchema: coreTool.outputSchema,
         execute: coreTool.execute,
         toolType: "workflow"
       };
@@ -1229,13 +1592,32 @@ var MCPServer = class extends MCPServerBase {
         name: toolName,
         description: coreTool.description,
         parameters: coreTool.parameters,
+        outputSchema: coreTool.outputSchema,
         execute: coreTool.execute
       };
       this.logger.info(`Registered explicit tool: '${toolName}'`);
     }
     this.logger.info(`Total defined tools registered: ${Object.keys(definedConvertedTools).length}`);
-    const agentDerivedTools = this.convertAgentsToTools(agentsConfig, definedConvertedTools);
-    const workflowDerivedTools = this.convertWorkflowsToTools(workflowsConfig, definedConvertedTools);
+    let agentDerivedTools = {};
+    let workflowDerivedTools = {};
+    try {
+      agentDerivedTools = this.convertAgentsToTools(agentsConfig, definedConvertedTools);
+      workflowDerivedTools = this.convertWorkflowsToTools(workflowsConfig, definedConvertedTools);
+    } catch (e) {
+      const mastraError = new MastraError(
+        {
+          id: "MCP_SERVER_AGENT_OR_WORKFLOW_TOOL_CONVERSION_FAILED",
+          domain: ErrorDomain.MCP,
+          category: ErrorCategory.USER
+        },
+        e
+      );
+      this.logger.trackException(mastraError);
+      this.logger.error("Failed to convert tools:", {
+        error: mastraError.toString()
+      });
+      throw mastraError;
+    }
     const allConvertedTools = { ...definedConvertedTools, ...agentDerivedTools, ...workflowDerivedTools };
     const finalToolCount = Object.keys(allConvertedTools).length;
     const definedCount = Object.keys(definedConvertedTools).length;
@@ -1257,11 +1639,17 @@ var MCPServer = class extends MCPServerBase {
     this.server.setRequestHandler(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;
+        })
       };
     });
   }
@@ -1284,7 +1672,6 @@ var MCPServer = class extends 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}'`, {
@@ -1303,17 +1690,38 @@ var MCPServer = class extends 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 z.ZodError) {
@@ -1587,7 +1995,23 @@ var MCPServer = class extends MCPServerBase {
    */
   async startStdio() {
     this.stdioTransport = new StdioServerTransport();
-    await this.server.connect(this.stdioTransport);
+    try {
+      await this.server.connect(this.stdioTransport);
+    } catch (error) {
+      const mastraError = new MastraError(
+        {
+          id: "MCP_SERVER_STDIO_CONNECTION_FAILED",
+          domain: ErrorDomain.MCP,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+      this.logger.trackException(mastraError);
+      this.logger.error("Failed to connect MCP server using stdio transport:", {
+        error: mastraError.toString()
+      });
+      throw mastraError;
+    }
     this.logger.info("Started MCP Server (stdio)");
   }
   /**
@@ -1601,23 +2025,42 @@ var MCPServer = class extends MCPServerBase {
    * @param res HTTP response (must support .write/.end)
    */
   async startSSE({ url, ssePath, messagePath, req, res }) {
-    if (url.pathname === ssePath) {
-      await this.connectSSE({
-        messagePath,
-        res
-      });
-    } else if (url.pathname === messagePath) {
-      this.logger.debug("Received message");
-      if (!this.sseTransport) {
-        res.writeHead(503);
-        res.end("SSE connection not established");
-        return;
+    try {
+      if (url.pathname === ssePath) {
+        await this.connectSSE({
+          messagePath,
+          res
+        });
+      } else if (url.pathname === messagePath) {
+        this.logger.debug("Received message");
+        if (!this.sseTransport) {
+          res.writeHead(503);
+          res.end("SSE connection not established");
+          return;
+        }
+        await this.sseTransport.handlePostMessage(req, res);
+      } else {
+        this.logger.debug("Unknown path:", { path: url.pathname });
+        res.writeHead(404);
+        res.end();
       }
-      await this.sseTransport.handlePostMessage(req, res);
-    } else {
-      this.logger.debug("Unknown path:", { path: url.pathname });
-      res.writeHead(404);
-      res.end();
+    } catch (e) {
+      const mastraError = new MastraError(
+        {
+          id: "MCP_SERVER_SSE_START_FAILED",
+          domain: ErrorDomain.MCP,
+          category: ErrorCategory.USER,
+          details: {
+            url: url.toString(),
+            ssePath,
+            messagePath
+          }
+        },
+        e
+      );
+      this.logger.trackException(mastraError);
+      this.logger.error("Failed to start MCP Server (SSE):", { error: mastraError.toString() });
+      throw mastraError;
     }
   }
   /**
@@ -1630,31 +2073,50 @@ var MCPServer = class extends MCPServerBase {
    * @param context Incoming Hono context
    */
   async startHonoSSE({ url, ssePath, messagePath, context }) {
-    if (url.pathname === ssePath) {
-      return streamSSE(context, async (stream) => {
-        await this.connectHonoSSE({
-          messagePath,
-          stream
+    try {
+      if (url.pathname === ssePath) {
+        return streamSSE(context, async (stream2) => {
+          await this.connectHonoSSE({
+            messagePath,
+            stream: stream2
+          });
         });
-      });
-    } else if (url.pathname === messagePath) {
-      this.logger.debug("Received message");
-      const sessionId = context.req.query("sessionId");
-      this.logger.debug("Received message for sessionId", { sessionId });
-      if (!sessionId) {
-        return context.text("No sessionId provided", 400);
-      }
-      if (!this.sseHonoTransports.has(sessionId)) {
-        return context.text(`No transport found for sessionId ${sessionId}`, 400);
-      }
-      const message = await this.sseHonoTransports.get(sessionId)?.handlePostMessage(context);
-      if (!message) {
-        return context.text("Transport not found", 400);
+      } else if (url.pathname === messagePath) {
+        this.logger.debug("Received message");
+        const sessionId = context.req.query("sessionId");
+        this.logger.debug("Received message for sessionId", { sessionId });
+        if (!sessionId) {
+          return context.text("No sessionId provided", 400);
+        }
+        if (!this.sseHonoTransports.has(sessionId)) {
+          return context.text(`No transport found for sessionId ${sessionId}`, 400);
+        }
+        const message = await this.sseHonoTransports.get(sessionId)?.handlePostMessage(context);
+        if (!message) {
+          return context.text("Transport not found", 400);
+        }
+        return message;
+      } else {
+        this.logger.debug("Unknown path:", { path: url.pathname });
+        return context.text("Unknown path", 404);
       }
-      return message;
-    } else {
-      this.logger.debug("Unknown path:", { path: url.pathname });
-      return context.text("Unknown path", 404);
+    } catch (e) {
+      const mastraError = new MastraError(
+        {
+          id: "MCP_SERVER_HONO_SSE_START_FAILED",
+          domain: ErrorDomain.MCP,
+          category: ErrorCategory.USER,
+          details: {
+            url: url.toString(),
+            ssePath,
+            messagePath
+          }
+        },
+        e
+      );
+      this.logger.trackException(mastraError);
+      this.logger.error("Failed to start MCP Server (Hono SSE):", { error: mastraError.toString() });
+      throw mastraError;
     }
   }
   /**
@@ -1783,7 +2245,17 @@ var MCPServer = class extends MCPServerBase {
         }
       }
     } catch (error) {
-      this.logger.error("startHTTP: Error handling Streamable HTTP request:", { error });
+      const mastraError = new MastraError(
+        {
+          id: "MCP_SERVER_HTTP_CONNECTION_FAILED",
+          domain: ErrorDomain.MCP,
+          category: ErrorCategory.USER,
+          text: "Failed to connect MCP server using HTTP transport"
+        },
+        error
+      );
+      this.logger.trackException(mastraError);
+      this.logger.error("startHTTP: Error handling Streamable HTTP request:", { error: mastraError });
       if (!res.headersSent) {
         res.writeHead(500, { "Content-Type": "application/json" });
         res.end(
@@ -1797,8 +2269,6 @@ var MCPServer = class extends MCPServerBase {
             // Cannot determine original request ID in catch
           })
         );
-      } else {
-        this.logger.error("startHTTP: Error after headers sent:", error);
       }
     }
   }
@@ -1806,38 +2276,72 @@ var MCPServer = class extends MCPServerBase {
     messagePath,
     res
   }) {
-    this.logger.debug("Received SSE connection");
-    this.sseTransport = new SSEServerTransport(messagePath, res);
-    await this.server.connect(this.sseTransport);
-    this.server.onclose = async () => {
-      this.sseTransport = void 0;
-      await this.server.close();
-    };
-    res.on("close", () => {
-      this.sseTransport = void 0;
-    });
+    try {
+      this.logger.debug("Received SSE connection");
+      this.sseTransport = new SSEServerTransport(messagePath, res);
+      await this.server.connect(this.sseTransport);
+      this.server.onclose = async () => {
+        this.sseTransport = void 0;
+        await this.server.close();
+      };
+      res.on("close", () => {
+        this.sseTransport = void 0;
+      });
+    } catch (e) {
+      const mastraError = new MastraError(
+        {
+          id: "MCP_SERVER_SSE_CONNECT_FAILED",
+          domain: ErrorDomain.MCP,
+          category: ErrorCategory.USER,
+          details: {
+            messagePath
+          }
+        },
+        e
+      );
+      this.logger.trackException(mastraError);
+      this.logger.error("Failed to connect to MCP Server (SSE):", { error: mastraError });
+      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);
     });
-    await this.server.connect(sseTransport);
-    this.server.onclose = async () => {
-      this.logger.debug("SSE Transport closed with sessionId:", { sessionId });
-      this.sseHonoTransports.delete(sessionId);
-      await this.server.close();
-    };
-    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);
+    try {
+      await this.server.connect(sseTransport);
+      this.server.onclose = async () => {
+        this.logger.debug("SSE Transport closed with sessionId:", { sessionId });
+        this.sseHonoTransports.delete(sessionId);
+        await this.server.close();
+      };
+      while (true) {
+        const sessionIds = Array.from(this.sseHonoTransports.keys() || []);
+        this.logger.debug("Active Hono SSE sessions:", { sessionIds });
+        await stream2.write(":keep-alive\n\n");
+        await stream2.sleep(6e4);
+      }
+    } catch (e) {
+      const mastraError = new MastraError(
+        {
+          id: "MCP_SERVER_HONO_SSE_CONNECT_FAILED",
+          domain: ErrorDomain.MCP,
+          category: ErrorCategory.USER,
+          details: {
+            messagePath
+          }
+        },
+        e
+      );
+      this.logger.trackException(mastraError);
+      this.logger.error("Failed to connect to MCP Server (Hono SSE):", { error: mastraError });
+      throw mastraError;
     }
   }
   /**
@@ -1875,7 +2379,17 @@ var MCPServer = class extends MCPServerBase {
       await this.server.close();
       this.logger.info("MCP server closed.");
     } catch (error) {
-      this.logger.error("Error closing MCP server:", { error });
+      const mastraError = new MastraError(
+        {
+          id: "MCP_SERVER_CLOSE_FAILED",
+          domain: ErrorDomain.MCP,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+      this.logger.trackException(mastraError);
+      this.logger.error("Error closing MCP server:", { error: mastraError });
+      throw mastraError;
     }
   }
   /**
@@ -1920,6 +2434,7 @@ var MCPServer = class extends MCPServerBase {
         name: tool.name,
         description: tool.description,
         inputSchema: tool.parameters?.jsonSchema || tool.parameters,
+        outputSchema: tool.outputSchema?.jsonSchema || tool.outputSchema,
         toolType: tool.toolType
       }))
     };
@@ -1940,6 +2455,7 @@ var MCPServer = class extends MCPServerBase {
       name: tool.name,
       description: tool.description,
       inputSchema: tool.parameters?.jsonSchema || tool.parameters,
+      outputSchema: tool.outputSchema?.jsonSchema || tool.outputSchema,
       toolType: tool.toolType
     };
   }
@@ -1953,30 +2469,47 @@ var MCPServer = class extends MCPServerBase {
    */
   async executeTool(toolId, args, executionContext) {
     const tool = this.convertedTools[toolId];
-    if (!tool) {
-      this.logger.warn(`ExecuteTool: Unknown tool '${toolId}' requested on MCPServer '${this.name}'.`);
-      throw new Error(`Unknown tool: ${toolId}`);
-    }
-    this.logger.debug(`ExecuteTool: Invoking '${toolId}' with arguments:`, args);
-    let validatedArgs = args;
-    if (tool.parameters instanceof 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(".")}: ${e.message}`).join(", ");
-        this.logger.warn(`ExecuteTool: Invalid tool arguments for '${toolId}': ${errorMessages}`, {
-          errors: validation.error.format()
-        });
-        throw new z.ZodError(validation.error.issues);
+    let validatedArgs;
+    try {
+      if (!tool) {
+        this.logger.warn(`ExecuteTool: Unknown tool '${toolId}' requested on MCPServer '${this.name}'.`);
+        throw new Error(`Unknown tool: ${toolId}`);
       }
-      validatedArgs = validation.data;
-    } else {
-      this.logger.debug(
-        `ExecuteTool: Tool '${toolId}' parameters is not a Zod schema with safeParse or is undefined. Skipping validation.`
+      this.logger.debug(`ExecuteTool: Invoking '${toolId}' with arguments:`, args);
+      if (tool.parameters instanceof 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(".")}: ${e.message}`).join(", ");
+          this.logger.warn(`ExecuteTool: Invalid tool arguments for '${toolId}': ${errorMessages}`, {
+            errors: validation.error.format()
+          });
+          throw new z.ZodError(validation.error.issues);
+        }
+        validatedArgs = validation.data;
+      } else {
+        this.logger.debug(
+          `ExecuteTool: Tool '${toolId}' parameters is not a Zod schema with safeParse or is undefined. Skipping validation.`
+        );
+      }
+      if (!tool.execute) {
+        this.logger.error(`ExecuteTool: Tool '${toolId}' does not have an execute function.`);
+        throw new Error(`Tool '${toolId}' cannot be executed.`);
+      }
+    } catch (error) {
+      const mastraError = new MastraError(
+        {
+          id: "MCP_SERVER_TOOL_EXECUTE_PREPARATION_FAILED",
+          domain: ErrorDomain.MCP,
+          category: ErrorCategory.USER,
+          details: {
+            toolId,
+            args
+          }
+        },
+        error
       );
-    }
-    if (!tool.execute) {
-      this.logger.error(`ExecuteTool: Tool '${toolId}' does not have an execute function.`);
-      throw new Error(`Tool '${toolId}' cannot be executed.`);
+      this.logger.trackException(mastraError);
+      throw mastraError;
     }
     try {
       const finalExecutionContext = {
@@ -1987,8 +2520,21 @@ var MCPServer = class extends MCPServerBase {
       this.logger.info(`ExecuteTool: Tool '${toolId}' executed successfully.`);
       return result;
     } catch (error) {
+      const mastraError = new MastraError(
+        {
+          id: "MCP_SERVER_TOOL_EXECUTE_FAILED",
+          domain: ErrorDomain.MCP,
+          category: ErrorCategory.USER,
+          details: {
+            toolId,
+            validatedArgs
+          }
+        },
+        error
+      );
+      this.logger.trackException(mastraError);
       this.logger.error(`ExecuteTool: Tool execution failed for '${toolId}':`, { error });
-      throw error instanceof Error ? error : new Error(`Execution of tool '${toolId}' failed: ${String(error)}`);
+      throw mastraError;
     }
   }
 };