@mastra/mcp 1.4.0 → 1.4.1-alpha.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @mastra/mcp
 
+## 1.4.1-alpha.0
+
+### Patch Changes
+
+- Standardized all logger calls across the codebase to use static string messages with structured data objects. Dynamic values are now passed as key-value pairs in the second argument instead of being interpolated into template literal strings. This improves log filterability and searchability in observability storage. ([#14899](https://github.com/mastra-ai/mastra/pull/14899))
+
+  Removed ~150 redundant or noisy log calls including duplicate error logging after trackException and verbose in-memory storage CRUD traces.
+
+- Updated dependencies [[`cbeec24`](https://github.com/mastra-ai/mastra/commit/cbeec24b3c97a1a296e7e461e66cc7f7d215dc50), [`cee146b`](https://github.com/mastra-ai/mastra/commit/cee146b5d858212e1df2b2730fc36d3ceda0e08d), [`aa0aeff`](https://github.com/mastra-ai/mastra/commit/aa0aeffa11efbef5e219fbd97bf43d263cfe3afe), [`2bcec65`](https://github.com/mastra-ai/mastra/commit/2bcec652d62b07eab15e9eb9822f70184526eede), [`ad9bded`](https://github.com/mastra-ai/mastra/commit/ad9bdedf86a824801f49928a8d40f6e31ff5450f), [`cbeec24`](https://github.com/mastra-ai/mastra/commit/cbeec24b3c97a1a296e7e461e66cc7f7d215dc50), [`208c0bb`](https://github.com/mastra-ai/mastra/commit/208c0bbacbf5a1da6318f2a0e0c544390e542ddc), [`f566ee7`](https://github.com/mastra-ai/mastra/commit/f566ee7d53a3da33a01103e2a5ac2070ddefe6b0)]:
+  - @mastra/core@1.20.0-alpha.0
+
 ## 1.4.0
 
 ### Minor Changes

package/dist/client/actions/prompt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../../src/client/actions/prompt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,oCAAoC,CAAC;AAClF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAEzD,UAAU,yBAAyB;IACjC,MAAM,EAAE,uBAAuB,CAAC;IAChC,MAAM,EAAE,aAAa,CAAC;CACvB;AAED;;;;;GAKG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0B;IACjD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IAEvC;;OAEG;gBACS,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,yBAAyB;IAKzD;;;;;;;;;;;;;;;OAeG;IACU,IAAI,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAyBtC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACU,GAAG,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAAE,GAAG,OAAO,CAAC,eAAe,CAAC;IAIxG;;;;;;;;;;;;;;;OAeG;IACU,aAAa,CAAC,OAAO,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CAG/D"}
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../../src/client/actions/prompt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,oCAAoC,CAAC;AAClF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAEzD,UAAU,yBAAyB;IACjC,MAAM,EAAE,uBAAuB,CAAC;IAChC,MAAM,EAAE,aAAa,CAAC;CACvB;AAED;;;;;GAKG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0B;IACjD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IAEvC;;OAEG;gBACS,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,yBAAyB;IAKzD;;;;;;;;;;;;;;;OAeG;IACU,IAAI,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IA2BtC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACU,GAAG,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAAE,GAAG,OAAO,CAAC,eAAe,CAAC;IAIxG;;;;;;;;;;;;;;;OAeG;IACU,aAAa,CAAC,OAAO,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CAG/D"}

package/dist/client/actions/resource.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../../../src/client/actions/resource.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,KAAK,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AACrF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAEzD,UAAU,2BAA2B;IACnC,MAAM,EAAE,uBAAuB,CAAC;IAChC,MAAM,EAAE,aAAa,CAAC;CACvB;AAED;;;;;;GAMG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0B;IACjD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IAEvC;;OAEG;gBACS,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,2BAA2B;IAK3D;;;;;;;;;;;;;;;OAeG;IACU,IAAI,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;IAyBxC;;;;;;;;;;;;;;;;OAgBG;IACU,SAAS,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;IA0BrD;;;;;;;;;;;;OAYG;IACU,IAAI,CAAC,GAAG,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;IAI7B;;;;;;;;;;;;;;OAcG;IACU,SAAS,CAAC,GAAG,EAAE,MAAM;;;;;;;;;IAIlC;;;;;;;;;;;;;OAaG;IACU,WAAW,CAAC,GAAG,EAAE,MAAM;;;;;;;;;IAIpC;;;;;;;;;;;;;;;;;OAiBG;IACU,SAAS,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAIjF;;;;;;;;;;;;;;;OAeG;IACU,aAAa,CAAC,OAAO,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CAG/D"}
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../../../src/client/actions/resource.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,KAAK,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AACrF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAEzD,UAAU,2BAA2B;IACnC,MAAM,EAAE,uBAAuB,CAAC;IAChC,MAAM,EAAE,aAAa,CAAC;CACvB;AAED;;;;;;GAMG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0B;IACjD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IAEvC;;OAEG;gBACS,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,2BAA2B;IAK3D;;;;;;;;;;;;;;;OAeG;IACU,IAAI,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;IA2BxC;;;;;;;;;;;;;;;;OAgBG;IACU,SAAS,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;IA2BrD;;;;;;;;;;;;OAYG;IACU,IAAI,CAAC,GAAG,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;IAI7B;;;;;;;;;;;;;;OAcG;IACU,SAAS,CAAC,GAAG,EAAE,MAAM;;;;;;;;;IAIlC;;;;;;;;;;;;;OAaG;IACU,WAAW,CAAC,GAAG,EAAE,MAAM;;;;;;;;;IAIpC;;;;;;;;;;;;;;;;;OAiBG;IACU,SAAS,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAIjF;;;;;;;;;;;;;;;OAeG;IACU,aAAa,CAAC,OAAO,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CAG/D"}

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-mcp
 description: Documentation for @mastra/mcp. Use when working with @mastra/mcp APIs, configuration, or implementation.
 metadata:
   package: "@mastra/mcp"
-  version: "1.4.0"
+  version: "1.4.1-alpha.0"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.4.0",
+  "version": "1.4.1-alpha.0",
   "package": "@mastra/mcp",
   "exports": {
     "UnauthorizedError": {

package/dist/index.cjs

@@ -134,7 +134,8 @@ var PromptClientActions = class {
       if (response && response.prompts && Array.isArray(response.prompts)) {
         return response.prompts.map((prompt) => ({ ...prompt }));
       } else {
-        this.logger.warn(`Prompts response from server ${this.client.name} did not have expected structure.`, {
+        this.logger.warn("Prompts response did not have expected structure", {
+          server: this.client.name,
           response
         });
         return [];
@@ -143,7 +144,8 @@ var PromptClientActions = class {
       if (e.code === types_js.ErrorCode.MethodNotFound) {
         return [];
       }
-      this.logger.error(`Error getting prompts from server ${this.client.name}`, {
+      this.logger.error("Error getting prompts from server", {
+        server: this.client.name,
         error: e instanceof Error ? e.message : String(e)
       });
       throw new Error(
@@ -232,7 +234,8 @@ var ResourceClientActions = class {
       if (response && response.resources && Array.isArray(response.resources)) {
         return response.resources;
       } else {
-        this.logger.warn(`Resources response from server ${this.client.name} did not have expected structure.`, {
+        this.logger.warn("Resources response did not have expected structure", {
+          server: this.client.name,
           response
         });
         return [];
@@ -241,7 +244,8 @@ var ResourceClientActions = class {
       if (e.code === types_js.ErrorCode.MethodNotFound) {
         return [];
       }
-      this.logger.error(`Error getting resources from server ${this.client.name}`, {
+      this.logger.error("Error getting resources from server", {
+        server: this.client.name,
         error: e instanceof Error ? e.message : String(e)
       });
       throw new Error(
@@ -272,17 +276,18 @@ var ResourceClientActions = class {
       if (response && response.resourceTemplates && Array.isArray(response.resourceTemplates)) {
         return response.resourceTemplates;
       } else {
-        this.logger.warn(
-          `Resource templates response from server ${this.client.name} did not have expected structure.`,
-          { response }
-        );
+        this.logger.warn("Resource templates response did not have expected structure", {
+          server: this.client.name,
+          response
+        });
         return [];
       }
     } catch (e) {
       if (e.code === types_js.ErrorCode.MethodNotFound) {
         return [];
       }
-      this.logger.error(`Error getting resource templates from server ${this.client.name}`, {
+      this.logger.error("Error getting resource templates from server", {
+        server: this.client.name,
         error: e instanceof Error ? e.message : String(e)
       });
       throw new Error(
@@ -1801,7 +1806,7 @@ To fix this you have three different options:
     }
     const exists = this.mcpClientsById.has(name);
     const existingClient = this.mcpClientsById.get(name);
-    this.logger.debug(`getConnectedClient ${name} exists: ${exists}`);
+    this.logger.debug("Checking connected client", { name, exists });
     if (exists) {
       if (!existingClient) {
         throw new Error(`Client ${name} exists but is undefined`);
@@ -1809,7 +1814,7 @@ To fix this you have three different options:
       await existingClient.connect();
       return existingClient;
     }
-    this.logger.debug(`Connecting to ${name} MCP server`);
+    this.logger.debug("Connecting to MCP server", { name });
     const mcpClient = new InternalMastraMCPClient({
       name,
       server: config,
@@ -1837,7 +1842,7 @@ To fix this you have three different options:
       this.mcpClientsById.delete(name);
       throw mastraError;
     }
-    this.logger.debug(`Connected to ${name} MCP server`);
+    this.logger.debug("Connected to MCP server", { name });
     return mcpClient;
   }
   async getConnectedClientForServer(serverName) {
@@ -2614,9 +2619,13 @@ var MCPServer = class extends mcp.MCPServerBase {
         ...this.instructions ? { instructions: this.instructions } : {}
       }
     );
-    this.logger.info(
-      `Initialized MCPServer '${this.name}' v${this.version} (ID: ${this.id}) with tools: ${Object.keys(this.convertedTools).join(", ")} and resources. Capabilities: ${JSON.stringify(capabilities)}`
-    );
+    this.logger.info("Initialized MCPServer", {
+      name: this.name,
+      version: this.version,
+      id: this.id,
+      tools: Object.keys(this.convertedTools),
+      capabilities
+    });
     this.sseHonoTransports = /* @__PURE__ */ new Map();
     this.registerHandlersOnServer(this.server);
     this.resources = new ServerResourceActions({
@@ -2653,10 +2662,10 @@ var MCPServer = class extends mcp.MCPServerBase {
    * @returns Promise that resolves to the client's response
    */
   async handleElicitationRequest(request, serverInstance, options) {
-    this.logger.debug(`Sending elicitation request: ${request.message}`);
+    this.logger.debug("Sending elicitation request", { message: request.message });
     const server = serverInstance || this.server;
     const response = await server.elicitInput(request, options);
-    this.logger.debug(`Received elicitation response: ${JSON.stringify(response)}`);
+    this.logger.debug("Received elicitation response", { response });
     return response;
   }
   /**
@@ -2728,7 +2737,6 @@ var MCPServer = class extends mcp.MCPServerBase {
    */
   registerHandlersOnServer(serverInstance) {
     serverInstance.setRequestHandler(types_js.ListToolsRequestSchema, async () => {
-      this.logger.debug("Handling ListTools request");
       return {
         tools: Object.values(this.convertedTools).map((tool) => {
           const toolSpec = {
@@ -2754,7 +2762,7 @@ var MCPServer = class extends mcp.MCPServerBase {
       try {
         const tool = this.convertedTools[request.params.name];
         if (!tool) {
-          this.logger.warn(`CallTool: Unknown tool '${request.params.name}' requested.`);
+          this.logger.warn("Unknown tool requested", { tool: request.params.name });
           return {
             content: [{ type: "text", text: `Unknown tool: ${request.params.name}` }],
             isError: true
@@ -2762,7 +2770,8 @@ var MCPServer = class extends mcp.MCPServerBase {
         }
         const validation = tool.parameters.validate?.(request.params.arguments ?? {});
         if (validation && !validation.success) {
-          this.logger.warn(`CallTool: Invalid tool arguments for '${request.params.name}'`, {
+          this.logger.warn("Invalid tool arguments", {
+            tool: request.params.name,
             errors: validation.error
           });
           let errorMessages = "Validation failed";
@@ -2786,7 +2795,7 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
           };
         }
         if (!tool.execute) {
-          this.logger.warn(`CallTool: Tool '${request.params.name}' does not have an execute function.`);
+          this.logger.warn("Tool does not have an execute function", { tool: request.params.name });
           return {
             content: [{ type: "text", text: `Tool '${request.params.name}' does not have an execute function.` }],
             isError: true
@@ -2843,7 +2852,8 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
           }
           const outputValidation = tool.outputSchema.validate?.(structuredContent ?? {});
           if (outputValidation && !outputValidation.success) {
-            this.logger.warn(`CallTool: Invalid structured content for '${request.params.name}'`, {
+            this.logger.warn("Invalid structured content", {
+              tool: request.params.name,
               errors: outputValidation.error
             });
             throw new Error(
@@ -2882,7 +2892,7 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
             isError: true
           };
         }
-        this.logger.error(`Tool execution failed: ${request.params.name}`, { error: error$1 });
+        this.logger.error("Tool execution failed", { tool: request.params.name, error: error$1 });
         if (error$1 instanceof error.MastraError) {
           return {
             content: [{ type: "text", text: JSON.stringify(error$1.toJSON()) }],
@@ -2897,7 +2907,7 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
     });
     serverInstance.setRequestHandler(types_js.SetLevelRequestSchema, async (request) => {
       this.currentLoggingLevel = request.params.level;
-      this.logger.debug(`Logging level set to: ${request.params.level}`);
+      this.logger.debug("Logging level set", { level: request.params.level });
       return {};
     });
     if (this.resourceOptions) {
@@ -2915,17 +2925,16 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
     if (!capturedResourceOptions) return;
     if (capturedResourceOptions.listResources) {
       serverInstance.setRequestHandler(types_js.ListResourcesRequestSchema, async (_request, extra) => {
-        this.logger.debug("Handling ListResources request");
         if (this.definedResources) {
           return { resources: this.definedResources };
         } else {
           try {
             const resources = await capturedResourceOptions.listResources({ extra });
             this.definedResources = resources;
-            this.logger.debug(`Fetched and cached ${this.definedResources.length} resources.`);
+            this.logger.debug("Fetched and cached resources", { count: this.definedResources.length });
             return { resources: this.definedResources };
           } catch (error) {
-            this.logger.error("Error fetching resources via listResources():", { error });
+            this.logger.error("Error fetching resources", { error });
             throw error;
           }
         }
@@ -2935,7 +2944,7 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
       serverInstance.setRequestHandler(types_js.ReadResourceRequestSchema, async (request, extra) => {
         const startTime = Date.now();
         const uri = request.params.uri;
-        this.logger.debug(`Handling ReadResource request for URI: ${uri}`);
+        this.logger.debug("Handling ReadResource request", { uri });
         if (!this.definedResources) {
           const resources = await this.resourceOptions?.listResources?.({ extra });
           if (!resources) throw new Error("Failed to load resources");
@@ -2943,7 +2952,7 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
         }
         const resource = this.definedResources?.find((r) => r.uri === uri);
         if (!resource) {
-          this.logger.warn(`ReadResource: Unknown resource URI '${uri}' requested.`);
+          this.logger.warn("Unknown resource URI requested", { uri });
           throw new Error(`Resource not found: ${uri}`);
         }
         try {
@@ -2968,27 +2977,26 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
             };
           });
           const duration = Date.now() - startTime;
-          this.logger.info(`Resource '${uri}' read successfully in ${duration}ms.`);
+          this.logger.info("Resource read successfully", { uri, duration });
           return {
             contents
           };
         } catch (error) {
           const duration = Date.now() - startTime;
-          this.logger.error(`Failed to get content for resource URI '${uri}' in ${duration}ms`, { error });
+          this.logger.error("Failed to get content for resource", { uri, duration, error });
           throw error;
         }
       });
     }
     if (capturedResourceOptions.resourceTemplates) {
       serverInstance.setRequestHandler(types_js.ListResourceTemplatesRequestSchema, async (_request, extra) => {
-        this.logger.debug("Handling ListResourceTemplates request");
         if (this.definedResourceTemplates) {
           return { resourceTemplates: this.definedResourceTemplates };
         } else {
           try {
             const templates = await capturedResourceOptions.resourceTemplates({ extra });
             this.definedResourceTemplates = templates;
-            this.logger.debug(`Fetched and cached ${this.definedResourceTemplates.length} resource templates.`);
+            this.logger.debug("Fetched and cached resource templates", { count: this.definedResourceTemplates.length });
             return { resourceTemplates: this.definedResourceTemplates };
           } catch (error) {
             this.logger.error("Error fetching resource templates via resourceTemplates():", { error });
@@ -2999,13 +3007,13 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
     }
     serverInstance.setRequestHandler(types_js.SubscribeRequestSchema, async (request) => {
       const uri = request.params.uri;
-      this.logger.info(`Received resources/subscribe request for URI: ${uri}`);
+      this.logger.info("Received resources/subscribe request", { 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.logger.info("Received resources/unsubscribe request", { uri });
       this.subscriptions.delete(uri);
       return {};
     });
@@ -3030,7 +3038,7 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
               types_js.PromptSchema.parse(prompt);
             }
             this.definedPrompts = prompts;
-            this.logger.debug(`Fetched and cached ${this.definedPrompts.length} prompts.`);
+            this.logger.debug("Fetched and cached prompts", { count: this.definedPrompts.length });
             return {
               prompts: this.definedPrompts
             };
@@ -3069,11 +3077,11 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
               messages = await capturedPromptOptions.getPromptMessages({ name, version: prompt.version, args, extra });
             }
             const duration = Date.now() - startTime;
-            this.logger.info(`Prompt '${name}' retrieved successfully in ${duration}ms.`);
+            this.logger.info("Prompt retrieved successfully", { prompt: name, duration });
             return { description: prompt.description, messages };
           } catch (error) {
             const duration = Date.now() - startTime;
-            this.logger.error(`Failed to get content for prompt '${name}' in ${duration}ms`, { error });
+            this.logger.error("Failed to get prompt content", { prompt: name, duration, error });
             throw error;
           }
         }
@@ -3088,7 +3096,7 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
     for (const agentKey in agentsConfig) {
       const agent = agentsConfig[agentKey];
       if (!agent || !("generate" in agent)) {
-        this.logger.warn(`Agent instance for '${agentKey}' is invalid or missing a generate function. Skipping.`);
+        this.logger.warn("Invalid agent instance, skipping", { agentKey });
         continue;
       }
       const agentDescription = agent.getDescription();
@@ -3099,9 +3107,7 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
       }
       const agentToolName = `ask_${agentKey}`;
       if (definedConvertedTools?.[agentToolName] || agentTools[agentToolName]) {
-        this.logger.warn(
-          `Tool with name '${agentToolName}' already exists. Agent '${agentKey}' will not be added as a duplicate tool.`
-        );
+        this.logger.warn("Duplicate tool name, skipping agent", { tool: agentToolName, agentKey });
         continue;
       }
       const agentToolDefinition = tools.createTool({
@@ -3117,9 +3123,7 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
         },
         execute: async (inputData, context) => {
           const { message } = inputData;
-          this.logger.debug(
-            `Executing agent tool '${agentToolName}' for agent '${agent.name}' with message: "${message}"`
-          );
+          this.logger.debug("Executing agent tool", { tool: agentToolName, agent: agent.name, message });
           try {
             const proxiedContext = context?.requestContext || new requestContext.RequestContext();
             if (context?.mcp?.extra) {
@@ -3133,7 +3137,7 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
             });
             return response;
           } catch (error) {
-            this.logger.error(`Error executing agent tool '${agentToolName}' for agent '${agent.name}':`, error);
+            this.logger.error("Error executing agent tool", { tool: agentToolName, agent: agent.name, error });
             throw error;
           }
         }
@@ -3154,7 +3158,7 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
           toolType: "agent"
         }
       };
-      this.logger.info(`Registered agent '${agent.name}' (key: '${agentKey}') as tool: '${agentToolName}'`);
+      this.logger.info("Registered agent as tool", { agent: agent.name, key: agentKey, tool: agentToolName });
     }
     return agentTools;
   }
@@ -3232,7 +3236,11 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
           toolType: "workflow"
         }
       };
-      this.logger.info(`Registered workflow '${workflow.id}' (key: '${workflowKey}') as tool: '${workflowToolName}'`);
+      this.logger.info("Registered workflow as tool", {
+        workflow: workflow.id,
+        key: workflowKey,
+        tool: workflowToolName
+      });
     }
     return workflowTools;
   }
@@ -3249,11 +3257,11 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
     for (const toolName of Object.keys(tools)) {
       const toolInstance = tools[toolName];
       if (!toolInstance) {
-        this.logger.warn(`Tool instance for '${toolName}' is undefined. Skipping.`);
+        this.logger.warn("Tool instance is undefined, skipping", { tool: toolName });
         continue;
       }
       if (typeof toolInstance.execute !== "function") {
-        this.logger.warn(`Tool '${toolName}' does not have a valid execute function. Skipping.`);
+        this.logger.warn("Tool has no execute function, skipping", { tool: toolName });
         continue;
       }
       const options = {
@@ -3269,9 +3277,9 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
         ...coreTool,
         id: toolName
       };
-      this.logger.info(`Registered explicit tool: '${toolName}'`);
+      this.logger.info("Registered explicit tool", { tool: toolName });
     }
-    this.logger.info(`Total defined tools registered: ${Object.keys(definedConvertedTools).length}`);
+    this.logger.info("Total defined tools registered", { count: Object.keys(definedConvertedTools).length });
     let agentDerivedTools = {};
     let workflowDerivedTools = {};
     try {
@@ -3565,16 +3573,16 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
     res,
     options
   }) {
-    this.logger.debug(`startHTTP: Received ${req.method} request to ${url.pathname}`);
+    this.logger.debug("Received HTTP request", { method: req.method, path: url.pathname });
     if (url.pathname !== httpPath) {
-      this.logger.debug(`startHTTP: Pathname ${url.pathname} does not match httpPath ${httpPath}. Returning 404.`);
+      this.logger.debug("Pathname does not match httpPath, returning 404", { path: url.pathname, httpPath });
       res.writeHead(404);
       res.end();
       return;
     }
     const isStatelessMode = options?.serverless || options && "sessionIdGenerator" in options && options.sessionIdGenerator === void 0;
     if (isStatelessMode) {
-      this.logger.debug("startHTTP: Running in stateless mode (serverless or sessionIdGenerator: undefined)");
+      this.logger.debug("Running in stateless mode");
       await this.handleServerlessRequest(req, res);
       return;
     }
@@ -3586,27 +3594,26 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
     };
     const sessionId = req.headers["mcp-session-id"];
     let transport;
-    this.logger.debug(
-      `startHTTP: Session ID from headers: ${sessionId}. Active transports: ${Array.from(this.streamableHTTPTransports.keys()).join(", ")}`
-    );
+    this.logger.debug("Session ID from headers", {
+      sessionId,
+      activeTransports: Array.from(this.streamableHTTPTransports.keys())
+    });
     try {
       if (sessionId && this.streamableHTTPTransports.has(sessionId)) {
         transport = this.streamableHTTPTransports.get(sessionId);
-        this.logger.debug(`startHTTP: Using existing Streamable HTTP transport for session ID: ${sessionId}`);
+        this.logger.debug("Using existing transport for session", { sessionId });
         if (req.method === "GET") {
-          this.logger.debug(
-            `startHTTP: Handling GET request for existing session ${sessionId}. Calling transport.handleRequest.`
-          );
+          this.logger.debug("Handling GET request for existing session", { sessionId });
         }
         const body = req.method === "POST" ? await this.readJsonBody(req) : void 0;
         await transport.handleRequest(req, res, body);
       } else {
-        this.logger.debug(`startHTTP: No existing Streamable HTTP session ID found. ${req.method}`);
+        this.logger.debug("No existing session found", { method: req.method });
         if (req.method === "POST") {
           const body = await this.readJsonBody(req);
           const { isInitializeRequest } = await import('@modelcontextprotocol/sdk/types.js');
           if (isInitializeRequest(body)) {
-            this.logger.debug("startHTTP: Received Streamable HTTP initialize request, creating new transport.");
+            this.logger.debug("Received initialize request, creating new transport");
             transport = new streamableHttp_js$1.StreamableHTTPServerTransport({
               ...mergedOptions,
               sessionIdGenerator: mergedOptions.sessionIdGenerator,
@@ -3617,13 +3624,11 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
             transport.onclose = () => {
               const closedSessionId = transport?.sessionId;
               if (closedSessionId && this.streamableHTTPTransports.has(closedSessionId)) {
-                this.logger.debug(
-                  `startHTTP: Streamable HTTP transport closed for session ${closedSessionId}, removing from map.`
-                );
+                this.logger.debug("Transport closed for session, removing from map", { sessionId: closedSessionId });
                 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}`);
+                  this.logger.debug("Cleaned up server instance for closed session", { sessionId: closedSessionId });
                 }
               }
             };
@@ -3632,15 +3637,13 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
             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}`
-              );
+              this.logger.debug("Session initialized and stored", { sessionId: transport.sessionId });
             } else {
-              this.logger.warn("startHTTP: Streamable HTTP transport initialized without a session ID.");
+              this.logger.warn("Transport initialized without a session ID");
             }
             return await transport.handleRequest(req, res, body);
           } else {
-            this.logger.warn("startHTTP: Received non-initialize POST request without a session ID.");
+            this.logger.warn("Received non-initialize POST request without session ID");
             res.writeHead(400, { "Content-Type": "application/json" });
             res.end(
               JSON.stringify({
@@ -3655,7 +3658,7 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
             );
           }
         } else {
-          this.logger.warn(`startHTTP: Received ${req.method} request without a session ID.`);
+          this.logger.warn("Received request without session ID", { method: req.method });
           res.writeHead(400, { "Content-Type": "application/json" });
           res.end(
             JSON.stringify({
@@ -3680,7 +3683,7 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
         error$1
       );
       this.logger.trackException(mastraError);
-      this.logger.error("startHTTP: Error handling Streamable HTTP request:", { error: mastraError });
+      this.logger.error("Error handling HTTP request", { error: mastraError });
       if (!res.headersSent) {
         res.writeHead(500, { "Content-Type": "application/json" });
         res.end(
@@ -3712,10 +3715,11 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
    */
   async handleServerlessRequest(req, res) {
     try {
-      this.logger.debug(`handleServerlessRequest: Received ${req.method} request`);
+      this.logger.debug("Received serverless request", { method: req.method });
       const body = req.method === "POST" ? await this.readJsonBody(req) : void 0;
-      this.logger.debug(`handleServerlessRequest: Processing ${req.method} request`, {
-        method: body?.method,
+      this.logger.debug("Processing serverless request", {
+        method: req.method,
+        bodyMethod: body?.method,
         id: body?.id
       });
       const transientServer = this.createServerInstance();
@@ -3725,7 +3729,7 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
       });
       await transientServer.connect(tempTransport);
       await tempTransport.handleRequest(req, res, body);
-      this.logger.debug(`handleServerlessRequest: Completed ${body?.method} request`, { id: body?.id });
+      this.logger.debug("Completed serverless request", { method: body?.method, id: body?.id });
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
@@ -3737,7 +3741,7 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
         error$1
       );
       this.logger.trackException(mastraError);
-      this.logger.error("handleServerlessRequest: Error handling request:", { error: mastraError });
+      this.logger.error("Error handling serverless request", { error: mastraError });
       if (!res.headersSent) {
         res.writeHead(500, { "Content-Type": "application/json" });
         res.end(
@@ -4004,7 +4008,7 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
    * ```
    */
   getToolListInfo() {
-    this.logger.debug(`Getting tool list information for MCPServer '${this.name}'`);
+    this.logger.debug("Getting tool list", { server: this.name });
     return {
       tools: Object.entries(this.convertedTools).map(([toolId, tool]) => ({
         id: toolId,
@@ -4037,10 +4041,10 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
   getToolInfo(toolId) {
     const tool = this.convertedTools[toolId];
     if (!tool) {
-      this.logger.debug(`Tool '${toolId}' not found on MCPServer '${this.name}'`);
+      this.logger.debug("Tool not found", { tool: toolId, server: this.name });
       return void 0;
     }
-    this.logger.debug(`Getting info for tool '${toolId}' on MCPServer '${this.name}'`);
+    this.logger.debug("Getting tool info", { tool: toolId, server: this.name });
     return {
       name: tool.id || toolId,
       description: tool.description,
@@ -4076,10 +4080,10 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
     let validatedArgs = args;
     try {
       if (!tool) {
-        this.logger.warn(`ExecuteTool: Unknown tool '${toolId}' requested on MCPServer '${this.name}'.`);
+        this.logger.warn("Unknown tool requested", { tool: toolId, server: this.name });
         throw new Error(`Unknown tool: ${toolId}`);
       }
-      this.logger.debug(`ExecuteTool: Invoking '${toolId}' with arguments:`, args);
+      this.logger.debug("Invoking tool", { tool: toolId, args });
       const paramsSchema = tool.parameters;
       const validation = typeof paramsSchema?.validate === "function" ? paramsSchema.validate(args ?? {}) : typeof paramsSchema?.safeParse === "function" ? paramsSchema.safeParse(args ?? {}) : null;
       if (validation) {
@@ -4090,7 +4094,9 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
             (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}`, {
+          this.logger.warn("Invalid tool arguments", {
+            tool: toolId,
+            errorMessages,
             errors: validationErrors
           });
           return {
@@ -4104,12 +4110,10 @@ Provided arguments: ${JSON.stringify(args, null, 2)}`,
         }
         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.`
-        );
+        this.logger.debug("Tool parameters missing schema, skipping validation", { tool: toolId });
       }
       if (!tool.execute) {
-        this.logger.error(`ExecuteTool: Tool '${toolId}' does not have an execute function.`);
+        this.logger.error("Tool does not have an execute function", { tool: toolId });
         throw new Error(`Tool '${toolId}' cannot be executed.`);
       }
     } catch (error$1) {
@@ -4134,7 +4138,7 @@ Provided arguments: ${JSON.stringify(args, null, 2)}`,
         toolCallId: executionContext?.toolCallId || crypto$1.randomUUID()
       };
       const result = await tool.execute(validatedArgs, finalExecutionContext);
-      this.logger.info(`ExecuteTool: Tool '${toolId}' executed successfully.`);
+      this.logger.info("Tool executed successfully", { tool: toolId });
       return result;
     } catch (error$1) {
       const mastraError = new error.MastraError(
@@ -4150,7 +4154,6 @@ Provided arguments: ${JSON.stringify(args, null, 2)}`,
         error$1
       );
       this.logger.trackException(mastraError);
-      this.logger.error(`ExecuteTool: Tool execution failed for '${toolId}':`, { error: error$1 });
       throw mastraError;
     }
   }