@mastra/mcp 0.10.5-alpha.0 → 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';
@@ -10,7 +11,6 @@ import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSche
 import { asyncExitHook, gracefulExit } from 'exit-hook';
 import { z } from 'zod';
 import { convertJsonSchemaToZod } from 'zod-from-json-schema';
-import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
 import equal from 'fast-deep-equal';
 import { v5 } from 'uuid';
 import { randomUUID } from 'crypto';
@@ -21,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 {
@@ -493,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() {
@@ -507,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;
@@ -929,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;
@@ -940,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();
@@ -959,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}`
@@ -1330,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(
@@ -1354,6 +1552,7 @@ var MCPServer = class extends MCPServerBase {
         name: workflowToolName,
         description: coreTool.description,
         parameters: coreTool.parameters,
+        outputSchema: coreTool.outputSchema,
         execute: coreTool.execute,
         toolType: "workflow"
       };
@@ -1393,6 +1592,7 @@ 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}'`);
@@ -1439,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;
+        })
       };
     });
   }
@@ -1466,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}'`, {
@@ -1485,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) {
@@ -1849,10 +2075,10 @@ var MCPServer = class extends MCPServerBase {
   async startHonoSSE({ url, ssePath, messagePath, context }) {
     try {
       if (url.pathname === ssePath) {
-        return streamSSE(context, async (stream) => {
+        return streamSSE(context, async (stream2) => {
           await this.connectHonoSSE({
             messagePath,
-            stream
+            stream: stream2
           });
         });
       } else if (url.pathname === messagePath) {
@@ -2078,13 +2304,13 @@ var MCPServer = class extends MCPServerBase {
       throw mastraError;
     }
   }
-  async connectHonoSSE({ messagePath, stream }) {
+  async connectHonoSSE({ messagePath, stream: stream2 }) {
     this.logger.debug("Received SSE connection");
-    const sseTransport = new SSETransport(messagePath, stream);
+    const sseTransport = new SSETransport(messagePath, stream2);
     const sessionId = sseTransport.sessionId;
     this.logger.debug("SSE Transport created with sessionId:", { sessionId });
     this.sseHonoTransports.set(sessionId, sseTransport);
-    stream.onAbort(() => {
+    stream2.onAbort(() => {
       this.logger.debug("SSE Transport aborted with sessionId:", { sessionId });
       this.sseHonoTransports.delete(sessionId);
     });
@@ -2098,8 +2324,8 @@ var MCPServer = class extends MCPServerBase {
       while (true) {
         const sessionIds = Array.from(this.sseHonoTransports.keys() || []);
         this.logger.debug("Active Hono SSE sessions:", { sessionIds });
-        await stream.write(":keep-alive\n\n");
-        await stream.sleep(6e4);
+        await stream2.write(":keep-alive\n\n");
+        await stream2.sleep(6e4);
       }
     } catch (e) {
       const mastraError = new MastraError(
@@ -2208,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
       }))
     };
@@ -2228,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
     };
   }

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.5-alpha.0",
+  "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.7-alpha.1"
+    "@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/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);
+  });
+});