Prompt Auto-Optimizer MCP

Instructions

Implementation Reference

• src/mcp/server.ts:327-346 (schema)

  Defines the input schema, description, and parameters for the gepa_recover_component MCP tool.
  name: 'gepa_recover_component', description: 'Recover a specific GEPA component', inputSchema: { type: 'object', properties: { componentType: { type: 'string', enum: ['evolution_engine', 'pareto_frontier', 'llm_adapter', 'trajectory_store', 'memory_cache'], description: 'Type of component to recover' }, strategy: { type: 'string', enum: ['restart', 'restore_from_backup', 'rebuild', 'reset_to_defaults'], default: 'restart', description: 'Recovery strategy to use' } }, required: ['componentType'] } },
• src/mcp/server.ts:598-602 (registration)

  Registers the gepa_recover_component tool in the MCP server's CallToolRequestSchema handler switch statement.
  case 'gepa_recover_component': return await this.recoverComponent(args as { componentType: string; strategy?: string; });
• src/mcp/server.ts:1662-1734 (handler)

  MCP server handler method for gepa_recover_component tool. Maps parameters, calls DisasterRecoverySystem.recoverComponent, handles response formatting and errors.
  private async recoverComponent(params: { componentType: string; strategy?: string; }): Promise<{ content: { type: string; text: string; }[] }> { const { componentType, strategy = 'restart' } = params; try { await this.disasterRecovery.initialize(); // Map component types to internal types const componentMap: Record<string, any> = { 'evolution_engine': 'evolution_engine', 'pareto_frontier': 'pareto_frontier', 'llm_adapter': 'llm_adapter', 'trajectory_store': 'trajectory_store', 'memory_cache': 'memory_cache' }; const mappedComponentType = componentMap[componentType]; if (!mappedComponentType) { throw new Error(`Unknown component type: ${componentType}`); } const strategyMap: Record<string, any> = { 'restart': 'restart', 'restore_from_backup': 'restore_from_backup', 'rebuild': 'rebuild', 'reset_to_defaults': 'reset_to_defaults' }; const mappedStrategy = strategyMap[strategy]; if (!mappedStrategy) { throw new Error(`Unknown recovery strategy: ${strategy}`); } const result = await this.disasterRecovery.recoverComponent(mappedComponentType, mappedStrategy); return { content: [ { type: 'text', text: `# Component Recovery ${result.success ? 'Completed' : 'Failed'} ## Recovery Details - **Component**: ${componentType} - **Strategy**: ${strategy} - **Success**: ${result.success ? 'Yes' : 'No'} - **Duration**: ${result.duration} ms - **Start Time**: ${result.startTime.toISOString()} - **End Time**: ${result.endTime?.toISOString() || 'In progress'} ## Recovery Logs ${result.logs.map(log => `[${log}]`).join('\n')} ${result.preRecoveryState ? `## Pre-Recovery State - Status: ${result.preRecoveryState.status} - Last Action: ${result.preRecoveryState.lastAction}` : ''} ${result.postRecoveryState ? `## Post-Recovery State - Status: ${result.postRecoveryState.status} - Last Action: ${result.postRecoveryState.lastAction}` : ''} ${result.error ? `## Error ${result.error.message}` : ''} ${result.success ? `Component ${componentType} has been successfully recovered using ${strategy} strategy.` : `Component recovery failed. Check the error details and logs above.`}`, }, ], }; } catch (error) { throw new Error(`Failed to recover component: ${error instanceof Error ? error.message : 'Unknown error'}`); } }
• src/core/disaster-recovery/component-recovery-manager.ts:170-249 (handler)

  Core implementation of component recovery logic in ComponentRecoveryManager. Orchestrates the recovery process including strategy execution, health checks, and state management.
  async recoverComponent( componentType: ComponentType, strategy?: RecoveryStrategy ): Promise<RecoveryAttempt> { return this.resilience.executeWithFullProtection( async () => { // Check if component is already being recovered const activeRecovery = Array.from(this.activeRecoveries.values()) .find(r => r.componentType === componentType && !r.endTime); if (activeRecovery) { throw new Error(`Component ${componentType} is already being recovered`); } // Get component configuration const componentConfig = this.config.componentConfigs.get(componentType); if (!componentConfig) { throw new Error(`No configuration found for component: ${componentType}`); } // Determine recovery strategy const selectedStrategy = strategy || this.selectOptimalStrategy(componentType); // Create recovery attempt const attempt: RecoveryAttempt = { id: this.generateRecoveryId(), componentType, strategy: selectedStrategy, startTime: new Date(), success: false, logs: [], preRecoveryState: await this.captureComponentState(componentType) }; this.activeRecoveries.set(attempt.id, attempt); try { // Execute recovery strategy await this.executeRecoveryStrategy(attempt); attempt.success = true; attempt.endTime = new Date(); attempt.duration = attempt.endTime.getTime() - attempt.startTime.getTime(); attempt.postRecoveryState = await this.captureComponentState(componentType); // Update component health await this.updateComponentHealth(componentType); // Record recovery history this.recordRecoveryAttempt(attempt); this.emit('componentRecovered', attempt); } catch (error) { attempt.success = false; attempt.error = error as Error; attempt.endTime = new Date(); attempt.duration = attempt.endTime.getTime() - attempt.startTime.getTime(); attempt.logs.push(`Recovery failed: ${(error as Error).message}`); this.recordRecoveryAttempt(attempt); this.emit('componentRecoveryFailed', attempt); throw error; } finally { this.activeRecoveries.delete(attempt.id); } return attempt; }, { serviceName: 'component-recovery', context: { name: 'recover-component', priority: 'high' } } ); }
• src/core/disaster-recovery/index.ts:295-297 (helper)

  Proxy method in DisasterRecoverySystem that delegates to ComponentRecoveryManager.recoverComponent.
  async recoverComponent(componentType: ComponentType, strategy?: RecoveryStrategy): Promise<RecoveryAttempt> { return this.componentRecoveryManager.recoverComponent(componentType, strategy); }