@mastra/mcp 0.10.4 → 0.10.5-alpha.1

package/integration-tests/node_modules/.bin/vitest

@@ -10,9 +10,9 @@ case `uname` in
 esac
 
 if [ -z "$NODE_PATH" ]; then
-  export NODE_PATH="/home/runner/work/mastra/mastra/node_modules/.pnpm/vitest@3.2.3_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.19.0_@vitest+ui@_3e45f0297eeb1f6a4ee30770ed0f557b/node_modules/vitest/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/vitest@3.2.3_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.19.0_@vitest+ui@_3e45f0297eeb1f6a4ee30770ed0f557b/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/node_modules"
+  export NODE_PATH="/home/runner/work/mastra/mastra/node_modules/.pnpm/vitest@3.2.4_@types+debug@4.1.12_@types+node@20.19.1_@vitest+ui@3.2.3_jiti@2.4.2_jsdom@_9ed2428c73777463a3d92e2c0ddae976/node_modules/vitest/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/vitest@3.2.4_@types+debug@4.1.12_@types+node@20.19.1_@vitest+ui@3.2.3_jiti@2.4.2_jsdom@_9ed2428c73777463a3d92e2c0ddae976/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/node_modules"
 else
-  export NODE_PATH="/home/runner/work/mastra/mastra/node_modules/.pnpm/vitest@3.2.3_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.19.0_@vitest+ui@_3e45f0297eeb1f6a4ee30770ed0f557b/node_modules/vitest/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/vitest@3.2.3_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.19.0_@vitest+ui@_3e45f0297eeb1f6a4ee30770ed0f557b/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/node_modules:$NODE_PATH"
+  export NODE_PATH="/home/runner/work/mastra/mastra/node_modules/.pnpm/vitest@3.2.4_@types+debug@4.1.12_@types+node@20.19.1_@vitest+ui@3.2.3_jiti@2.4.2_jsdom@_9ed2428c73777463a3d92e2c0ddae976/node_modules/vitest/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/vitest@3.2.4_@types+debug@4.1.12_@types+node@20.19.1_@vitest+ui@3.2.3_jiti@2.4.2_jsdom@_9ed2428c73777463a3d92e2c0ddae976/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/node_modules:$NODE_PATH"
 fi
 if [ -x "$basedir/node" ]; then
   exec "$basedir/node"  "$basedir/../vitest/vitest.mjs" "$@"

package/integration-tests/package.json

@@ -12,11 +12,11 @@
     "@mastra/client-js": "workspace:*",
     "@mastra/mcp": "workspace:*",
     "dotenv": "^16.5.0",
-    "zod": "^3.25.56"
+    "zod": "^3.25.67"
   },
   "devDependencies": {
     "@mastra/core": "workspace:*",
-    "@testing-library/react": "^16.2.0",
+    "@testing-library/react": "^16.3.0",
     "@types/node": "^20.17.57",
     "get-port": "^7.1.0",
     "mastra": "workspace:*",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/mcp",
-  "version": "0.10.4",
+  "version": "0.10.5-alpha.1",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -22,11 +22,10 @@
   "author": "",
   "license": "Elastic-2.0",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.1",
+    "@modelcontextprotocol/sdk": "^1.13.0",
     "date-fns": "^4.1.0",
     "exit-hook": "^4.0.0",
     "fast-deep-equal": "^3.1.3",
-    "hono": "^4.7.11",
     "uuid": "^11.1.0",
     "zod-from-json-schema": "^0.0.5"
   },
@@ -42,16 +41,17 @@
     "@microsoft/api-extractor": "^7.52.8",
     "@types/node": "^20.19.0",
     "ai": "4.3.16",
-    "eslint": "^9.28.0",
-    "hono-mcp-server-sse-transport": "0.0.6",
+    "eslint": "^9.29.0",
+    "hono-mcp-server-sse-transport": "0.0.7",
+    "hono": "^4.7.11",
     "tsup": "^8.5.0",
     "tsx": "^4.19.4",
     "typescript": "^5.8.3",
     "vitest": "^3.2.3",
-    "zod": "^3.25.57",
+    "zod": "^3.25.67",
     "zod-to-json-schema": "^3.24.5",
     "@internal/lint": "0.0.13",
-    "@mastra/core": "0.10.6"
+    "@mastra/core": "0.10.7-alpha.2"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",

package/src/__fixtures__/tools.ts

@@ -26,15 +26,6 @@ export const weatherTool = createTool({
   inputSchema: z.object({
     location: z.string().describe('City name'),
   }),
-  outputSchema: z.object({
-    temperature: z.number(),
-    feelsLike: z.number(),
-    humidity: z.number(),
-    windSpeed: z.number(),
-    windGust: z.number(),
-    conditions: z.string(),
-    location: z.string(),
-  }),
   execute: async ({ context }) => {
     console.log('weather tool', context);
     return await getWeather(context.location);

package/src/client/client.ts

@@ -1,6 +1,7 @@
 import { MastraBase } from '@mastra/core/base';
 
 import type { RuntimeContext } from '@mastra/core/di';
+import { ErrorCategory, ErrorDomain, MastraError } from '@mastra/core/error';
 import { createTool } from '@mastra/core/tools';
 import { isZodType } from '@mastra/core/utils';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
@@ -475,7 +476,48 @@ export class InternalMastraMCPClient extends MastraBase {
         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' },
+      });
+    }
+  }
+
+  private convertOutputSchema(
+    outputSchema: Awaited<ReturnType<Client['listTools']>>['tools'][0]['outputSchema'] | JSONSchema,
+  ): z.ZodType | undefined {
+    if (!outputSchema) return
+    if (isZodType(outputSchema)) {
+      return outputSchema;
+    }
+
+    try {
+      return convertJsonSchemaToZod(outputSchema as JSONSchema);
+    } catch (error: unknown) {
+      let errorDetails: string | undefined;
+      if (error instanceof Error) {
+        errorDetails = error.stack;
+      } else {
+        // Attempt to stringify, fallback to String()
+        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' },
+      });
     }
   }
 
@@ -490,6 +532,7 @@ export class InternalMastraMCPClient extends MastraBase {
           id: `${this.name}_${tool.name}`,
           description: tool.description || '',
           inputSchema: this.convertInputSchema(tool.inputSchema),
+          outputSchema: this.convertOutputSchema(tool.outputSchema),
           execute: async ({ context, runtimeContext }: { context: any; runtimeContext?: RuntimeContext | null }) => {
             const previousContext = this.currentOperationContext;
             this.currentOperationContext = runtimeContext || null; // Set current context
@@ -505,6 +548,7 @@ export class InternalMastraMCPClient extends MastraBase {
                   timeout: this.timeout,
                 },
               );
+
               this.log('debug', `Tool executed successfully: ${tool.name}`);
               return res;
             } catch (e) {

package/src/client/configuration.ts

@@ -1,4 +1,5 @@
 import { MastraBase } from '@mastra/core/base';
+import { ErrorCategory, ErrorDomain, MastraError } from '@mastra/core/error';
 import { DEFAULT_REQUEST_TIMEOUT_MSEC } from '@modelcontextprotocol/sdk/shared/protocol.js';
 import type { Prompt, Resource, ResourceTemplate } from '@modelcontextprotocol/sdk/types.js';
 import equal from 'fast-deep-equal';
@@ -74,7 +75,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;
@@ -86,30 +96,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: string, uri: string) => {
-        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: string, uri: string) => {
-        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: string, uri: string) => {
-        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: string, handler: (params: { uri: string }) => void) => {
-        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: string, handler: () => void) => {
-        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);
+        }
       },
     };
   }
@@ -124,18 +201,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}: {serverName: string, name: string, args?: Record<string, any>, version?: string}) => {
-        const internalClient = await this.getConnectedClientForServer(serverName);
-        return internalClient.prompts.get({name, args, version});
+      get: async ({ serverName, name, args, version }: { serverName: string, name: string, args?: Record<string, any>, version?: string }) => {
+        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: string, handler: () => void) => {
-        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);
+        }
       },
     };
   }
@@ -163,7 +272,7 @@ To fix this you have three different options:
     this.disconnectPromise = (async () => {
       try {
         mcpClientInstances.delete(this.id);
-        
+
         // Disconnect all clients in the cache
         await Promise.all(Array.from(this.mcpClientsById.values()).map(client => client.disconnect()));
         this.mcpClientsById.clear();
@@ -179,11 +288,19 @@ To fix this you have three different options:
     this.addToInstanceCache();
     const connectedTools: Record<string, any> = {}; // <- any because we don't have proper tool schemas
 
-    await this.eachClientTools(async ({ serverName, tools }) => {
-      for (const [toolName, toolConfig] of Object.entries(tools)) {
-        connectedTools[`${serverName}_${toolName}`] = toolConfig; // namespace tool to prevent tool name conflicts between servers
-      }
-    });
+    try {
+      await this.eachClientTools(async ({ serverName, tools }) => {
+        for (const [toolName, toolConfig] of Object.entries(tools)) {
+          connectedTools[`${serverName}_${toolName}`] = toolConfig; // namespace tool to prevent tool name conflicts between servers
+        }
+      });
+    } catch (error) {
+      throw new MastraError({
+        id: 'MCP_CLIENT_GET_TOOLS_FAILED',
+        domain: ErrorDomain.MCP,
+        category: ErrorCategory.THIRD_PARTY,
+      }, error);
+    }
 
     return connectedTools;
   }
@@ -192,11 +309,19 @@ To fix this you have three different options:
     this.addToInstanceCache();
     const connectedToolsets: Record<string, Record<string, any>> = {}; // <- any because we don't have proper tool schemas
 
-    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;
   }
@@ -258,13 +383,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;

package/src/server/promptActions.ts

@@ -1,3 +1,4 @@
+import { ErrorCategory, ErrorDomain, MastraError } from '@mastra/core/error';
 import type { IMastraLogger } from '@mastra/core/logger';
 import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
 
@@ -28,10 +29,20 @@ export class ServerPromptActions {
     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;
     }
   }
 }

package/src/server/resourceActions.ts

@@ -1,3 +1,4 @@
+import { ErrorCategory, ErrorDomain, MastraError } from '@mastra/core/error';
 import type { IMastraLogger } from '@mastra/core/logger';
 import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
 
@@ -34,8 +35,23 @@ export class ServerResourceActions {
       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.`);
@@ -55,8 +71,20 @@ export class ServerResourceActions {
     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;
     }
   }
 }

package/src/server/server.test.ts

@@ -1347,3 +1347,87 @@ describe('MCPServer - Workflow to Tool Conversion', () => {
     expect(server.tools()['run_unique_workflow_key_789']).toBeDefined();
   });
 });
+
+describe('MCPServer with Tool Output Schema', () => {
+  let serverWithOutputSchema: MCPServer;
+  let clientWithOutputSchema: MCPClient;
+  const PORT = 9600 + Math.floor(Math.random() * 1000);
+  let httpServerWithOutputSchema: http.Server;
+
+  const structuredTool: ToolsInput = {
+    structuredTool: {
+      description: 'A test tool with structured output',
+      parameters: z.object({ input: z.string() }),
+      outputSchema: z.object({
+        processedInput: z.string(),
+        timestamp: z.string(),
+      }),
+      execute: async ({ input }: { input: string }) => ({
+        structuredContent: {
+          processedInput: `processed: ${input}`,
+          timestamp: mockDateISO,
+        },
+      }),
+    },
+  };
+
+  beforeAll(async () => {
+    serverWithOutputSchema = new MCPServer({
+      name: 'Test MCP Server with OutputSchema',
+      version: '0.1.0',
+      tools: structuredTool,
+    });
+
+    httpServerWithOutputSchema = http.createServer(async (req: http.IncomingMessage, res: http.ServerResponse) => {
+      const url = new URL(req.url || '', `http://localhost:${PORT}`);
+      await serverWithOutputSchema.startHTTP({
+        url,
+        httpPath: '/http',
+        req,
+        res,
+      });
+    });
+
+    await new Promise<void>(resolve => httpServerWithOutputSchema.listen(PORT, () => resolve()));
+
+    clientWithOutputSchema = new MCPClient({
+      servers: {
+        local: {
+          url: new URL(`http://localhost:${PORT}/http`),
+        },
+      },
+    });
+  });
+
+  afterAll(async () => {
+    httpServerWithOutputSchema.closeAllConnections?.();
+    await new Promise<void>(resolve =>
+      httpServerWithOutputSchema.close(() => {
+        resolve();
+      }),
+    );
+    await serverWithOutputSchema.close();
+  });
+
+  it('should list tool with outputSchema', async () => {
+    const tools = await clientWithOutputSchema.getTools();
+    const tool = tools['local_structuredTool'];
+    expect(tool).toBeDefined();
+    expect(tool.outputSchema).toBeDefined();
+  });
+
+  it('should call tool and receive structuredContent', async () => {
+    const tools = await clientWithOutputSchema.getTools();
+    const tool = tools['local_structuredTool'];
+    const result = await tool.execute({ context: { input: 'hello' } });
+
+    expect(result).toBeDefined();
+    expect(result.structuredContent).toBeDefined();
+    expect(result.structuredContent.processedInput).toBe('processed: hello');
+    expect(result.structuredContent.timestamp).toBe(mockDateISO);
+
+    expect(result.content).toBeDefined();
+    expect(result.content[0].type).toBe('text');
+    expect(JSON.parse(result.content[0].text)).toEqual(result.structuredContent);
+  });
+});