// 请求消息结构
{
  "jsonrpc": "2.0",
  "method": "method_name",
  "params": {
    // 参数对象
  },
  "id": "unique_request_id"
}
// 响应消息结构
{
  "jsonrpc": "2.0",
  "result": {
    // 结果数据
  },
  "id": "unique_request_id"
}
// 错误响应结构
{
  "jsonrpc": "2.0",
  "error": {
    "code": -32000,
    "message": "Error description",
    "data": {
      // 额外错误信息
    }
  },
  "id": "unique_request_id"
}

// MCP初始化请求
{
  "jsonrpc": "2.0",
  "method": "initialize",
  "params": {
    "protocolVersion": "2024-11-05",
    "capabilities": {
      "resources": {
        "subscribe": true,
        "listChanged": true
      },
      "tools": {
        "listChanged": true
      },
      "prompts": {
        "listChanged": true
      }
    },
    "clientInfo": {
      "name": "ExampleClient",
      "version": "1.0.0"
    }
  },
  "id": "init-1"
}

// MCP标准错误代码
const MCP_ERROR_CODES = {
  // JSON-RPC标准错误
  PARSE_ERROR: -32700,
  INVALID_REQUEST: -32600,
  METHOD_NOT_FOUND: -32601,
  INVALID_PARAMS: -32602,
  INTERNAL_ERROR: -32603,
  
  // MCP扩展错误
  RESOURCE_NOT_FOUND: -32001,
  TOOL_EXECUTION_ERROR: -32002,
  PERMISSION_DENIED: -32003,
  RATE_LIMIT_EXCEEDED: -32004
};
// 错误处理示例
function handleMCPError(error) {
  switch (error.code) {
    case MCP_ERROR_CODES.RESOURCE_NOT_FOUND:
      console.error(`资源未找到: ${error.message}`);
      break;
    case MCP_ERROR_CODES.PERMISSION_DENIED:
      console.error(`权限不足: ${error.message}`);
      break;
    default:
      console.error(`未知错误: ${error.message}`);
  }
}

// 资源定义示例
class FileResource {
  constructor(uri, mimeType, description) {
    this.uri = uri;
    this.mimeType = mimeType;
    this.description = description;
  }
  
  // 资源元数据
  getMetadata() {
    return {
      uri: this.uri,
      mimeType: this.mimeType,
      description: this.description,
      annotations: {
        audience: ["user", "assistant"],
        priority: 0.5
      }
    };
  }
  
  // 资源内容读取
  async read() {
    try {
      const content = await fs.readFile(this.uri, 'utf8');
      return {
        contents: [{
          uri: this.uri,
          mimeType: this.mimeType,
          text: content
        }]
      };
    } catch (error) {
      throw new MCPError(
        MCP_ERROR_CODES.RESOURCE_NOT_FOUND,
        `无法读取资源: ${this.uri}`
      );
    }
  }
}

// 资源订阅实现
class ResourceSubscriptionManager {
  constructor() {
    this.subscriptions = new Map();
    this.watchers = new Map();
  }
  
  // 订阅资源变更
  async subscribe(uri, callback) {
    if (!this.subscriptions.has(uri)) {
      this.subscriptions.set(uri, new Set());
      this.startWatching(uri);
    }
    
    this.subscriptions.get(uri).add(callback);
  }
  
  // 启动资源监控
  startWatching(uri) {
    const watcher = fs.watch(uri, (eventType, filename) => {
      this.notifySubscribers(uri, {
        type: eventType,
        uri: uri,
        timestamp: new Date().toISOString()
      });
    });
    
    this.watchers.set(uri, watcher);
  }
  
  // 通知订阅者
  notifySubscribers(uri, changeEvent) {
    const subscribers = this.subscriptions.get(uri);
    if (subscribers) {
      subscribers.forEach(callback => {
        callback(changeEvent);
      });
    }
  }
}

// 工具定义接口
interface ToolDefinition {
  name: string;
  description: string;
  inputSchema: {
    type: "object";
    properties: Record<string, any>;
    required?: string[];
  };
}
// 具体工具实现示例
class DatabaseQueryTool {
  constructor(connectionString) {
    this.connection = new DatabaseConnection(connectionString);
  }
  
  // 工具元数据定义
  getDefinition() {
    return {
      name: "database_query",
      description: "执行SQL查询并返回结果",
      inputSchema: {
        type: "object",
        properties: {
          query: {
            type: "string",
            description: "要执行的SQL查询语句"
          },
          parameters: {
            type: "array",
            description: "查询参数数组",
            items: { type: "string" }
          }
        },
        required: ["query"]
      }
    };
  }
  
  // 工具执行逻辑
  async execute(args) {
    const { query, parameters = [] } = args;
    
    try {
      // 参数验证
      this.validateQuery(query);
      
      // 执行查询
      const result = await this.connection.query(query, parameters);
      
      return {
        content: [{
          type: "text",
          text: JSON.stringify(result, null, 2)
        }],
        isError: false
      };
    } catch (error) {
      return {
        content: [{
          type: "text",
          text: `查询执行失败: ${error.message}`
        }],
        isError: true
      };
    }
  }
  
  // 查询安全验证
  validateQuery(query) {
    const dangerousKeywords = ['DROP', 'DELETE', 'TRUNCATE', 'ALTER'];
    const upperQuery = query.toUpperCase();
    
    for (const keyword of dangerousKeywords) {
      if (upperQuery.includes(keyword)) {
        throw new Error(`不允许执行包含 ${keyword} 的查询`);
      }
    }
  }
}

// 提示词模板定义
class PromptTemplate {
  constructor(name, description, arguments) {
    this.name = name;
    this.description = description;
    this.arguments = arguments;
  }
  
  // 获取提示词定义
  getDefinition() {
    return {
      name: this.name,
      description: this.description,
      arguments: this.arguments.map(arg => ({
        name: arg.name,
        description: arg.description,
        required: arg.required || false
      }))
    };
  }
  
  // 生成具体提示词
  async generate(args) {
    // 参数验证
    this.validateArguments(args);
    
    // 生成提示词内容
    const content = await this.buildPromptContent(args);
    
    return {
      description: this.description,
      messages: content
    };
  }
}
// 代码审查提示词示例
class CodeReviewPrompt extends PromptTemplate {
  constructor() {
    super(
      "code_review",
      "代码审查提示词模板",
      [
        {
          name: "code",
          description: "要审查的代码内容",
          required: true
        },
        {
          name: "language",
          description: "编程语言",
          required: true
        },
        {
          name: "focus_areas",
          description: "重点关注的审查方面",
          required: false
        }
      ]
    );
  }
  
  async buildPromptContent(args) {
    const { code, language, focus_areas = [] } = args;
    
    let systemPrompt = `你是一位资深的${language}开发专家，请对以下代码进行详细审查：`;
    
    if (focus_areas.length > 0) {
      systemPrompt += `\n重点关注以下方面：${focus_areas.join(', ')}`;
    }
    
    return [
      {
        role: "system",
        content: {
          type: "text",
          text: systemPrompt
        }
      },
      {
        role: "user",
        content: {
          type: "text",
          text: `请审查以下${language}代码：\n\n\`\`\`${language}\n${code}\n\`\`\``
        }
      }
    ];
  }
}

// 版本协商实现
class VersionNegotiator {
  constructor(supportedVersions) {
    this.supportedVersions = supportedVersions.sort(this.compareVersions);
  }
  
  // 协商最佳版本
  negotiateVersion(clientVersions) {
    // 找到客户端和服务器都支持的最高版本
    for (const serverVersion of this.supportedVersions.reverse()) {
      for (const clientVersion of clientVersions) {
        if (this.isCompatible(serverVersion, clientVersion)) {
          return serverVersion;
        }
      }
    }
    
    throw new Error('无法找到兼容的协议版本');
  }
  
  // 版本兼容性检查
  isCompatible(serverVersion, clientVersion) {
    const [sMajor, sMinor] = serverVersion.split('.').map(Number);
    const [cMajor, cMinor] = clientVersion.split('.').map(Number);
    
    // 主版本必须相同
    if (sMajor !== cMajor) return false;
    
    // 服务器次版本应该 >= 客户端次版本
    return sMinor >= cMinor;
  }
  
  // 版本比较
  compareVersions(a, b) {
    const [aMajor, aMinor, aPatch] = a.split('.').map(Number);
    const [bMajor, bMinor, bPatch] = b.split('.').map(Number);
    
    if (aMajor !== bMajor) return aMajor - bMajor;
    if (aMinor !== bMinor) return aMinor - bMinor;
    return aPatch - bPatch;
  }
}

// 版本兼容性适配器
class CompatibilityAdapter {
  constructor(targetVersion, currentVersion) {
    this.targetVersion = targetVersion;
    this.currentVersion = currentVersion;
    this.adapters = new Map();
    this.initializeAdapters();
  }
  
  // 初始化适配器
  initializeAdapters() {
    // v1.0 到 v1.1 的适配
    this.adapters.set('1.0->1.1', {
      adaptRequest: (request) => {
        // 为旧版本请求添加默认的订阅能力
        if (request.method === 'initialize' && !request.params.capabilities.resources) {
          request.params.capabilities.resources = { subscribe: false };
        }
        return request;
      },
      adaptResponse: (response) => {
        // 移除新版本特有的字段
        if (response.result && response.result.capabilities) {
          delete response.result.capabilities.resources?.listChanged;
        }
        return response;
      }
    });
  }
  
  // 请求适配
  adaptRequest(request) {
    const adapterKey = `${this.currentVersion}->${this.targetVersion}`;
    const adapter = this.adapters.get(adapterKey);
    
    return adapter ? adapter.adaptRequest(request) : request;
  }
  
  // 响应适配
  adaptResponse(response) {
    const adapterKey = `${this.targetVersion}->${this.currentVersion}`;
    const adapter = this.adapters.get(adapterKey);
    
    return adapter ? adapter.adaptResponse(response) : response;
  }
}

// 协议扩展接口
interface MCPExtension {
  name: string;
  version: string;
  methods: Record<string, MethodHandler>;
  capabilities: ExtensionCapabilities;
}
// 扩展注册器
class ExtensionRegistry {
  constructor() {
    this.extensions = new Map();
    this.methodHandlers = new Map();
  }
  
  // 注册扩展
  registerExtension(extension) {
    // 验证扩展
    this.validateExtension(extension);
    
    // 注册扩展
    this.extensions.set(extension.name, extension);
    
    // 注册方法处理器
    Object.entries(extension.methods).forEach(([method, handler]) => {
      const fullMethodName = `${extension.name}/${method}`;
      this.methodHandlers.set(fullMethodName, handler);
    });
    
    console.log(`扩展 ${extension.name} v${extension.version} 注册成功`);
  }
  
  // 处理扩展方法调用
  async handleExtensionMethod(methodName, params) {
    const handler = this.methodHandlers.get(methodName);
    if (!handler) {
      throw new MCPError(
        MCP_ERROR_CODES.METHOD_NOT_FOUND,
        `扩展方法 ${methodName} 未找到`
      );
    }
    
    return await handler(params);
  }
}

// MCP连接池实现
class MCPConnectionPool {
  constructor(maxConnections = 10) {
    this.maxConnections = maxConnections;
    this.activeConnections = new Map();
    this.connectionQueue = [];
    this.metrics = {
      totalConnections: 0,
      activeCount: 0,
      queuedCount: 0
    };
  }
  
  // 获取连接
  async getConnection(serverUri) {
    // 检查是否有可用连接
    if (this.activeConnections.has(serverUri)) {
      const connection = this.activeConnections.get(serverUri);
      if (connection.isHealthy()) {
        return connection;
      }
    }
    
    // 创建新连接
    if (this.metrics.activeCount < this.maxConnections) {
      return await this.createConnection(serverUri);
    }
    
    // 等待连接可用
    return await this.waitForConnection(serverUri);
  }
  
  // 创建新连接
  async createConnection(serverUri) {
    const connection = new MCPConnection(serverUri);
    await connection.initialize();
    
    this.activeConnections.set(serverUri, connection);
    this.metrics.activeCount++;
    this.metrics.totalConnections++;
    
    // 设置连接事件监听
    connection.on('close', () => {
      this.activeConnections.delete(serverUri);
      this.metrics.activeCount--;
    });
    
    return connection;
  }
}

// 批处理请求管理器
class BatchRequestManager {
  constructor(batchSize = 10, batchTimeout = 100) {
    this.batchSize = batchSize;
    this.batchTimeout = batchTimeout;
    this.pendingRequests = [];
    this.batchTimer = null;
  }
  
  // 添加请求到批处理队列
  addRequest(request) {
    return new Promise((resolve, reject) => {
      this.pendingRequests.push({
        request,
        resolve,
        reject,
        timestamp: Date.now()
      });
      
      // 检查是否需要立即处理批次
      if (this.pendingRequests.length >= this.batchSize) {
        this.processBatch();
      } else if (!this.batchTimer) {
        // 设置超时处理
        this.batchTimer = setTimeout(() => {
          this.processBatch();
        }, this.batchTimeout);
      }
    });
  }
  
  // 处理批次请求
  async processBatch() {
    if (this.pendingRequests.length === 0) return;
    
    // 清除定时器
    if (this.batchTimer) {
      clearTimeout(this.batchTimer);
      this.batchTimer = null;
    }
    
    // 获取当前批次
    const currentBatch = this.pendingRequests.splice(0, this.batchSize);
    
    try {
      // 构建批量请求
      const batchRequest = {
        jsonrpc: "2.0",
        method: "batch",
        params: currentBatch.map(item => item.request)
      };
      
      // 发送批量请求
      const batchResponse = await this.sendBatchRequest(batchRequest);
      
      // 处理批量响应
      currentBatch.forEach((item, index) => {
        const response = batchResponse[index];
        if (response.error) {
          item.reject(new Error(response.error.message));
        } else {
          item.resolve(response.result);
        }
      });
    } catch (error) {
      // 批量请求失败，逐个拒绝
      currentBatch.forEach(item => {
        item.reject(error);
      });
    }
  }
}

// MCP权限控制实现
class MCPPermissionManager {
  constructor() {
    this.permissions = new Map();
    this.roleDefinitions = new Map();
    this.auditLog = [];
  }
  
  // 定义角色权限
  defineRole(roleName, permissions) {
    this.roleDefinitions.set(roleName, {
      permissions: new Set(permissions),
      createdAt: new Date(),
      updatedAt: new Date()
    });
  }
  
  // 检查权限
  async checkPermission(clientId, resource, action) {
    const clientPermissions = this.permissions.get(clientId);
    if (!clientPermissions) {
      this.logSecurityEvent('PERMISSION_DENIED', {
        clientId,
        resource,
        action,
        reason: 'No permissions found'
      });
      return false;
    }
    
    const hasPermission = clientPermissions.has(`${resource}:${action}`) ||
                         clientPermissions.has(`${resource}:*`) ||
                         clientPermissions.has('*:*');
    
    this.logSecurityEvent(hasPermission ? 'PERMISSION_GRANTED' : 'PERMISSION_DENIED', {
      clientId,
      resource,
      action
    });
    
    return hasPermission;
  }
  
  // 记录安全事件
  logSecurityEvent(eventType, details) {
    this.auditLog.push({
      timestamp: new Date().toISOString(),
      type: eventType,
      details,
      severity: this.getEventSeverity(eventType)
    });
    
    // 异步写入持久化存储
    this.persistAuditLog();
  }
}

// MCP安全传输层
class SecureMCPTransport {
  constructor(options = {}) {
    this.encryptionKey = options.encryptionKey || this.generateKey();
    this.compressionEnabled = options.compression || true;
    this.rateLimiter = new RateLimiter(options.rateLimit);
  }
  
  // 加密消息
  async encryptMessage(message) {
    const serialized = JSON.stringify(message);
    const compressed = this.compressionEnabled ? 
      await this.compress(serialized) : serialized;
    
    return await this.encrypt(compressed);
  }
  
  // 解密消息
  async decryptMessage(encryptedData) {
    const decrypted = await this.decrypt(encryptedData);
    const decompressed = this.compressionEnabled ? 
      await this.decompress(decrypted) : decrypted;
    
    return JSON.parse(decompressed);
  }
  
  // 发送安全消息
  async sendSecureMessage(message, clientId) {
    // 速率限制检查
    if (!await this.rateLimiter.checkLimit(clientId)) {
      throw new MCPError(
        MCP_ERROR_CODES.RATE_LIMIT_EXCEEDED,
        '请求频率超出限制'
      );
    }
    
    // 加密并发送
    const encryptedMessage = await this.encryptMessage(message);
    return await this.transport.send(encryptedMessage);
  }
}

# MCP监控系统实现
class MCPMonitoringSystem:
    def __init__(self):
        self.metrics_collector = MetricsCollector()
        self.alert_manager = AlertManager()
        self.dashboard = MonitoringDashboard()
    
    def collect_metrics(self):
        """收集MCP服务器指标"""
        metrics = {
            'response_time': self.measure_response_time(),
            'throughput': self.measure_throughput(),
            'error_rate': self.calculate_error_rate(),
            'active_connections': self.count_active_connections(),
            'resource_usage': self.get_resource_usage()
        }
        
        self.metrics_collector.record(metrics)
        self.check_alerts(metrics)
        return metrics
    
    def check_alerts(self, metrics):
        """检查告警条件"""
        alert_rules = [
            {
                'name': 'high_response_time',
                'condition': metrics['response_time'] > 500,
                'severity': 'warning',
                'message': f"响应时间过高: {metrics['response_time']}ms"
            },
            {
                'name': 'high_error_rate',
                'condition': metrics['error_rate'] > 0.01,
                'severity': 'critical',
                'message': f"错误率过高: {metrics['error_rate']*100:.2f}%"
            }
        ]
        
        for rule in alert_rules:
            if rule['condition']:
                self.alert_manager.trigger_alert(rule)

# MCP性能基准测试
import asyncio
import time
from concurrent.futures import ThreadPoolExecutor
class MCPBenchmark:
    def __init__(self, server_uri: str):
        self.server_uri = server_uri
        self.results = {}
    
    async def run_benchmark_suite(self):
        """运行完整的基准测试套件"""
        test_cases = [
            ('connection_test', self.test_connection_performance),
            ('throughput_test', self.test_throughput),
            ('latency_test', self.test_latency),
            ('concurrent_test', self.test_concurrent_requests),
            ('stress_test', self.test_stress_limits)
        ]
        
        for test_name, test_func in test_cases:
            print(f"运行测试: {test_name}")
            result = await test_func()
            self.results[test_name] = result
            print(f"测试完成: {test_name} - {result}")
    
    async def test_throughput(self, duration=60):
        """吞吐量测试"""
        start_time = time.time()
        request_count = 0
        
        async def make_request():
            nonlocal request_count
            client = MCPClient(self.server_uri)
            await client.connect()
            await client.call_tool('echo', {'message': 'benchmark'})
            request_count += 1
        
        # 持续发送请求
        while time.time() - start_time < duration:
            await make_request()
        
        throughput = request_count / duration
        return {
            'requests_per_second': throughput,
            'total_requests': request_count,
            'duration': duration
        }
    
    async def test_concurrent_requests(self, concurrent_users=100):
        """并发请求测试"""
        async def user_session():
            client = MCPClient(self.server_uri)
            await client.connect()
            
            start_time = time.time()
            for _ in range(10):  # 每个用户发送10个请求
                await client.call_tool('echo', {'message': 'concurrent_test'})
            end_time = time.time()
            
            return end_time - start_time
        
        # 创建并发用户会话
        tasks = [user_session() for _ in range(concurrent_users)]
        session_times = await asyncio.gather(*tasks)
        
        return {
            'concurrent_users': concurrent_users,
            'average_session_time': sum(session_times) / len(session_times),
            'max_session_time': max(session_times),
            'min_session_time': min(session_times)
        }

# MCP故障诊断工具
class MCPDiagnosticTool:
    def __init__(self, server_uri: str):
        self.server_uri = server_uri
        self.diagnostic_results = {}
    
    async def run_full_diagnostic(self):
        """运行完整诊断"""
        diagnostics = [
            ('connectivity', self.check_connectivity),
            ('protocol_version', self.check_protocol_version),
            ('capabilities', self.check_capabilities),
            ('performance', self.check_performance),
            ('security', self.check_security_config)
        ]
        
        for name, check_func in diagnostics:
            try:
                result = await check_func()
                self.diagnostic_results[name] = {
                    'status': 'PASS' if result['success'] else 'FAIL',
                    'details': result
                }
            except Exception as e:
                self.diagnostic_results[name] = {
                    'status': 'ERROR',
                    'error': str(e)
                }
        
        return self.generate_diagnostic_report()
    
    async def check_connectivity(self):
        """检查连接性"""
        try:
            client = MCPClient(self.server_uri)
            start_time = time.time()
            await client.connect()
            connection_time = time.time() - start_time
            
            return {
                'success': True,
                'connection_time': connection_time,
                'server_info': await client.get_server_info()
            }
        except Exception as e:
            return {
                'success': False,
                'error': str(e)
            }
    
    def generate_diagnostic_report(self):
        """生成诊断报告"""
        report = {
            'timestamp': datetime.now().isoformat(),
            'server_uri': self.server_uri,
            'overall_status': 'HEALTHY',
            'checks': self.diagnostic_results,
            'recommendations': []
        }
        
        # 分析结果并生成建议
        failed_checks = [name for name, result in self.diagnostic_results.items() 
                        if result['status'] != 'PASS']
        
        if failed_checks:
            report['overall_status'] = 'UNHEALTHY'
            report['recommendations'] = self.generate_recommendations(failed_checks)
        
        return report

// MCP调试工具
class MCPDebugger {
  constructor(options = {}) {
    this.logLevel = options.logLevel || 'INFO';
    this.traceEnabled = options.trace || false;
    this.messageHistory = [];
  }
  
  // 消息拦截器
  interceptMessage(direction, message) {
    const logEntry = {
      timestamp: new Date().toISOString(),
      direction, // 'SEND' or 'RECEIVE'
      message: JSON.parse(JSON.stringify(message)),
      size: JSON.stringify(message).length
    };
    
    this.messageHistory.push(logEntry);
    
    if (this.traceEnabled) {
      console.log(`[MCP ${direction}]`, logEntry);
    }
    
    // 检查消息异常
    this.analyzeMessage(logEntry);
  }
  
  // 消息分析
  analyzeMessage(logEntry) {
    const { message, direction } = logEntry;
    
    // 检查错误消息
    if (message.error) {
      console.warn(`[MCP ERROR] ${direction}:`, message.error);
    }
    
    // 检查性能问题
    if (logEntry.size > 1024 * 1024) { // 1MB
      console.warn(`[MCP PERF] Large message detected: ${logEntry.size} bytes`);
    }
    
    // 检查协议合规性
    if (!message.jsonrpc || message.jsonrpc !== '2.0') {
      console.error(`[MCP PROTOCOL] Invalid JSON-RPC version:`, message);
    }
  }
  
  // 生成调试报告
  generateDebugReport() {
    const report = {
      summary: {
        totalMessages: this.messageHistory.length,
        errorCount: this.messageHistory.filter(m => m.message.error).length,
        averageMessageSize: this.calculateAverageMessageSize(),
        timeRange: this.getTimeRange()
      },
      messageBreakdown: this.analyzeMessageTypes(),
      performanceMetrics: this.calculatePerformanceMetrics(),
      recommendations: this.generateDebugRecommendations()
    };
    
    return report;
  }
}