MCPサーバーレスポンスの検証：公式スキーマを活用した堅牢な実装

1// MCPの基本的なメッセージ型
2type JSONRPCMessage =
3  | JSONRPCRequest     // リクエスト
4  | JSONRPCNotification // 通知
5  | JSONRPCResponse     // 成功レスポンス
6  | JSONRPCError;       // エラーレスポンス
7
8// JSON-RPC 2.0のレスポンス型
9interface JSONRPCResponse {
10  jsonrpc: '2.0';
11  id: string | number;
12  result: {
13    _meta?: { [key: string]: unknown };
14    [key: string]: unknown;
15  };
16}

1{
2  "$schema": "http://json-schema.org/draft-07/schema#",
3  "definitions": {
4    // 基本メッセージ型
5    "JSONRPCMessage": { ... },
6    "JSONRPCRequest": { ... },
7    "JSONRPCResponse": { ... },
8    "JSONRPCError": { ... },
9    
10    // MCP固有の型
11    "ServerCapabilities": { ... },
12    "ClientCapabilities": { ... },
13    "Resource": { ... },
14    "Tool": { ... },
15    
16    // メソッド固有の型
17    "InitializeResult": { ... },
18    "ListResourcesResult": { ... },
19    "GetPromptResult": { ... }
20  }
21}

1{
2  "InitializeResult": {
3    "description": "After receiving an initialize request from the client, the server sends this response.",
4    "properties": {
5      "protocolVersion": {
6        "description": "The version of the Model Context Protocol that the server wants to use.",
7        "type": "string"
8      },
9      "capabilities": {
10        "$ref": "#/definitions/ServerCapabilities"
11      },
12      "serverInfo": {
13        "$ref": "#/definitions/Implementation"
14      },
15      "instructions": {
16        "description": "Instructions describing how to use the server and its features.",
17        "type": "string"
18      }
19    },
20    "required": [
21      "capabilities",
22      "protocolVersion",
23      "serverInfo"
24    ]
25  }
26}

1npm install ajv ajv-formats

1import { Ajv, ErrorObject } from 'ajv';
2import addFormats from 'ajv-formats';
3import schema from './schema.json';
4
5export type MCPMethod = 'initialize' | 'resources/list' | 'prompts/get' | 'tools/call';
6
7export class MCPValidator {
8  private ajv: Ajv;
9  private validators: Map<MCPMethod, ReturnType<Ajv['compile']>>;
10
11  constructor() {
12    // Ajvインスタンスの初期化
13    this.ajv = new Ajv({
14      allErrors: true,    // すべてのエラーを収集
15      verbose: true,      // 詳細なエラー情報
16      strict: true        // 厳密モード
17    });
18    addFormats(this.ajv); // URI等のフォーマット検証を追加
19
20    // バリデータの初期化
21    this.validators = new Map();
22    this.initializeValidators();
23  }
24
25  private initializeValidators() {
26    // 各メソッドに対応するバリデータを初期化
27    const methodSchemas = {
28      'initialize': schema.definitions.InitializeResult,
29      'resources/list': schema.definitions.ListResourcesResult,
30      'prompts/get': schema.definitions.GetPromptResult,
31      'tools/call': schema.definitions.CallToolResult
32    };
33
34    for (const [method, methodSchema] of Object.entries(methodSchemas)) {
35      this.validators.set(method as MCPMethod, this.ajv.compile(methodSchema));
36    }
37  }
38}

1export class MCPValidator {
2  // ... 前述のコード ...
3
4  /**
5   * MCPレスポンスをバリデートします
6   * @param response バリデーション対象のレスポンス
7   * @param method MCPメソッド名
8   * @returns バリデーション結果とエラー情報のタプル
9   */
10  validate(response: unknown, method: MCPMethod): ValidationResult {
11    // JSON-RPC 2.0の基本構造を検証
12    if (!this.isValidJSONRPCResponse(response)) {
13      return {
14        isValid: false,
15        errors: [{ message: 'Invalid JSON-RPC 2.0 response structure' }]
16      };
17    }
18
19    // メソッド固有のバリデータを取得
20    const validator = this.validators.get(method);
21    if (!validator) {
22      throw new Error(`Unknown method: ${method}`);
23    }
24
25    // レスポンスの検証
26    const isValid = validator(response.result);
27    return {
28      isValid,
29      errors: validator.errors ?? []
30    };
31  }
32
33  private isValidJSONRPCResponse(response: unknown): response is JSONRPCResponse {
34    return (
35      typeof response === 'object' &&
36      response !== null &&
37      'jsonrpc' in response &&
38      response.jsonrpc === '2.0' &&
39      'id' in response &&
40      (typeof response.id === 'string' || typeof response.id === 'number') &&
41      'result' in response &&
42      typeof response.result === 'object'
43    );
44  }
45}

1export class MCPValidator {
2  // ... 前述のコード ...
3
4  /**
5   * バリデーションエラーを人間が読みやすい形式に変換します
6   */
7  formatErrors(errors: ErrorObject[]): string[] {
8    return errors.map(error => {
9      const path = error.instancePath || 'response';
10      const message = error.message || 'Unknown error';
11
12      // 必須フィールドのエラー
13      if (error.keyword === 'required') {
14        const missing = error.params.missingProperty;
15        return `${path}: Missing required property '${missing}'`;
16      }
17
18      // 型のエラー
19      if (error.keyword === 'type') {
20        const expected = error.params.type;
21        return `${path}: Expected type '${expected}'`;
22      }
23
24      // その他のエラー
25      return `${path}: ${message}`;
26    });
27  }
28}

1const validator = new MCPValidator();
2
3// リソース一覧のレスポンスを検証する例
4const response = {
5  jsonrpc: '2.0',
6  id: 1,
7  result: {
8    resources: [
9      {
10        uri: 'file:///path/to/resource',
11        name: 'Example Resource',
12        description: 'An example resource',
13        mimeType: 'text/plain'
14      }
15    ]
16  }
17};
18
19const result = validator.validate(response, 'resources/list');
20
21if (!result.isValid) {
22  console.error('Validation errors:');
23  validator.formatErrors(result.errors).forEach(error => {
24    console.error(`- ${error}`);
25  });
26} else {
27  console.log('Response is valid');
28}

1import schema from './schema.json';
2import { writeFileSync, mkdirSync } from 'fs';
3import { join } from 'path';
4
5// メソッドごとのスキーマを抽出
6const methodSchemas = {
7  'initialize': schema.definitions.InitializeResult,
8  'resources/list': schema.definitions.ListResourcesResult,
9  'prompts/get': schema.definitions.GetPromptResult,
10  'tools/call': schema.definitions.CallToolResult
11};
12
13// スキーマを個別のファイルとして保存
14const outputDir = join(__dirname, 'schemas');
15mkdirSync(outputDir, { recursive: true });
16
17for (const [method, methodSchema] of Object.entries(methodSchemas)) {
18  const fileName = method.replace('/', '-') + '.schema.json';
19  const filePath = join(outputDir, fileName);
20  
21  writeFileSync(filePath, JSON.stringify(methodSchema, null, 2));
22  console.log(`Generated schema for ${method} at ${filePath}`);
23}

1export class OptimizedMCPValidator {
2  private ajv: Ajv;
3  private cachedValidators: Map<MCPMethod, ReturnType<Ajv['compile']>>;
4  private loadingValidators: Map<MCPMethod, Promise<void>>;
5
6  constructor() {
7    this.ajv = new Ajv({ allErrors: true, strict: true });
8    addFormats(this.ajv);
9    
10    this.cachedValidators = new Map();
11    this.loadingValidators = new Map();
12  }
13
14  /**
15   * メソッド用のバリデータを非同期でロード
16   */
17  private async loadValidator(method: MCPMethod): Promise<void> {
18    // すでにロード済みの場合はスキップ
19    if (this.cachedValidators.has(method)) {
20      return;
21    }
22
23    // ロード中の場合は待機
24    const loading = this.loadingValidators.get(method);
25    if (loading) {
26      return loading;
27    }
28
29    // 新しくロードを開始
30    const loadPromise = (async () => {
31      const schemaFileName = method.replace('/', '-') + '.schema.json';
32      const schema = await import(`./schemas/${schemaFileName}`);
33      this.cachedValidators.set(method, this.ajv.compile(schema));
34    })();
35
36    this.loadingValidators.set(method, loadPromise);
37    await loadPromise;
38    this.loadingValidators.delete(method);
39  }
40
41  /**
42   * 非同期バリデーション
43   */
44  async validate(response: unknown, method: MCPMethod): Promise<ValidationResult> {
45    await this.loadValidator(method);
46    const validator = this.cachedValidators.get(method);
47    
48    if (!validator) {
49      throw new Error(`Failed to load validator for method: ${method}`);
50    }
51
52    const isValid = validator(response.result);
53    return {
54      isValid,
55      errors: validator.errors ?? []
56    };
57  }
58}

1export class OptimizedMCPValidator {
2  constructor() {
3    this.ajv = new Ajv({
4      allErrors: false,      // 最初のエラーで停止
5      strict: true,          // 厳密モード
6      validateFormats: false // パフォーマンスのためフォーマット検証を無効化
7    });
8
9    // 必須の形式のみ追加
10    addFormats(this.ajv, [
11      'uri',        // リソースURIに必要
12      'uri-template' // テンプレートに必要
13    ]);
14  }
15
16  /**
17   * パフォーマンス重視のバリデーション
18   */
19  async validateFast(response: unknown, method: MCPMethod): Promise<boolean> {
20    // 基本構造の高速チェック
21    if (
22      typeof response !== 'object' ||
23      response === null ||
24      response.jsonrpc !== '2.0' ||
25      !('result' in response)
26    ) {
27      return false;
28    }
29
30    // キャッシュされたバリデータを使用
31    const validator = this.cachedValidators.get(method);
32    if (!validator) {
33      await this.loadValidator(method);
34      return this.validateFast(response, method);
35    }
36
37    return validator(response.result);
38  }
39}