address comments: 1. validate schemas w/o codegen, 2. relax no-structured-output restriction

Author: bhosmer-ant

package-lock.json

@@ -46,13 +46,13 @@
  "client": "tsx src/cli.ts client"
  },
  "dependencies": {
+ "ajv": "^8.17.1",
  "content-type": "^1.0.5",
  "cors": "^2.8.5",
  "cross-spawn": "^7.0.5",
  "eventsource": "^3.0.2",
  "express": "^5.0.1",
  "express-rate-limit": "^7.5.0",
- "json-schema-to-zod": "^2.6.1",
  "pkce-challenge": "^5.0.0",
  "raw-body": "^3.0.0",
  "zod": "^3.23.8",

package.json

@@ -1261,72 +1261,5 @@ describe('outputSchema validation', () => {
  );
  });
 
- /***
- * Test: Throw Error when Tool Without outputSchema Returns structuredContent
- */
- test('should throw error when tool without outputSchema returns structuredContent', async () => {
- const server = new Server({
- name: 'test-server',
- version: '1.0.0',
- }, {
- capabilities: {
- tools: {},
- },
- });
-
- // Set up server handlers
- server.setRequestHandler(InitializeRequestSchema, async (request) => ({
- protocolVersion: request.params.protocolVersion,
- capabilities: {},
- serverInfo: {
- name: 'test-server',
- version: '1.0.0',
- }
- }));
-
- server.setRequestHandler(ListToolsRequestSchema, async () => ({
- tools: [
- {
- name: 'test-tool',
- description: 'A test tool',
- inputSchema: {
- type: 'object',
- properties: {},
- },
- // No outputSchema defined
- },
- ],
- }));
-
- server.setRequestHandler(CallToolRequestSchema, async (request) => {
- if (request.params.name === 'test-tool') {
- // Incorrectly return structuredContent for a tool without outputSchema
- return {
- structuredContent: { result: 'This should not be allowed' },
- };
- }
- throw new Error('Unknown tool');
- });
-
- const client = new Client({
- name: 'test-client',
- version: '1.0.0',
- });
-
- const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-
- await Promise.all([
- client.connect(clientTransport),
- server.connect(serverTransport),
- ]);
-
- // List tools to cache the schemas
- await client.listTools();
-
- // Call the tool - should throw validation error
- await expect(client.callTool({ name: 'test-tool' })).rejects.toThrow(
- /Tool without outputSchema cannot return structuredContent/
- );
- });
 
 });

src/client/index.test.ts

@@ -43,8 +43,7 @@ import {
  ErrorCode,
  McpError,
 } from "../types.js";
-import { z } from "zod";
-import { JsonSchema, parseSchema } from "json-schema-to-zod";
+import { Ajv, type ValidateFunction } from "ajv";
 
 export type ClientOptions = ProtocolOptions & {
  /**
@@ -91,7 +90,8 @@ export class Client<
  private _serverVersion?: Implementation;
  private _capabilities: ClientCapabilities;
  private _instructions?: string;
- private _cachedToolOutputSchemas: Map<string, z.ZodTypeAny> = new Map();
+ private _cachedToolOutputValidators: Map<string, ValidateFunction> = new Map();
+ private _ajv: InstanceType<typeof Ajv>;
 
  /**
  * Initializes this client with the given name and version information.
@@ -102,6 +102,7 @@ export class Client<
  ) {
  super(options);
  this._capabilities = options?.capabilities ?? {};
+ this._ajv = new Ajv({ strict: false, validateFormats: true });
  }
 
  /**
@@ -426,8 +427,8 @@ export class Client<
  );
 
  // Check if the tool has an outputSchema
- const outputSchema = this.getToolOutputSchema(params.name);
- if (outputSchema) {
+ const validator = this.getToolOutputValidator(params.name);
+ if (validator) {
  // If tool has outputSchema, it MUST return structuredContent (unless it's an error)
  if (!result.structuredContent && !result.isError) {
  throw new McpError(
@@ -440,12 +441,12 @@ export class Client<
  if (result.structuredContent) {
  try {
  // Validate the structured content (which is already an object) against the schema
- const validationResult = outputSchema.safeParse(result.structuredContent);
+ const isValid = validator(result.structuredContent);
 
- if (!validationResult.success) {
+ if (!isValid) {
  throw new McpError(
  ErrorCode.InvalidParams,
- `Structured content does not match the tool's output schema: ${validationResult.error.message}`
+ `Structured content does not match the tool's output schema: ${this._ajv.errorsText(validator.errors)}`
  );
  }
  } catch (error) {
@@ -458,41 +459,29 @@ export class Client<
  );
  }
  }
- } else {
- // If tool doesn't have outputSchema, it MUST NOT return structuredContent
- if (result.structuredContent) {
- throw new McpError(
- ErrorCode.InvalidRequest,
- `Tool without outputSchema cannot return structuredContent`
- );
- }
  }
 
  return result;
  }
 
  private cacheToolOutputSchemas(tools: Tool[]) {
- this._cachedToolOutputSchemas.clear();
+ this._cachedToolOutputValidators.clear();
 
  for (const tool of tools) {
- // If the tool has an outputSchema, create and cache the Zod schema
+ // If the tool has an outputSchema, create and cache the Ajv validator
  if (tool.outputSchema) {
  try {
- const zodSchemaCode = parseSchema(tool.outputSchema as JsonSchema);
- // The library returns a string of Zod code, we need to evaluate it
- // Using Function constructor to safely evaluate the Zod schema
- const createSchema = new Function('z', `return ${zodSchemaCode}`);
- const zodSchema = createSchema(z);
- this._cachedToolOutputSchemas.set(tool.name, zodSchema);
+ const validator = this._ajv.compile(tool.outputSchema);
+ this._cachedToolOutputValidators.set(tool.name, validator);
  } catch (error) {
- console.warn(`Failed to create Zod schema for tool ${tool.name}: ${error}`);
+ console.warn(`Failed to compile output schema for tool ${tool.name}: ${error}`);
  }
  }
  }
  }
 
- private getToolOutputSchema(toolName: string): z.ZodTypeAny | undefined {
- return this._cachedToolOutputSchemas.get(toolName);
+ private getToolOutputValidator(toolName: string): ValidateFunction | undefined {
+ return this._cachedToolOutputValidators.get(toolName);
  }
 
  async listTools(