il2cpp-dump-analyzer-mcp/dist/agent/mcp-tool-selector.d.ts

Agentic RAG system for analyzing IL2CPP dump.cs files from Unity games

/**
 * @fileoverview Intelligent MCP Tool Selection and Execution
 * Provides smart tool selection algorithms, capability mapping, and enhanced execution
 * for complex IL2CPP analysis workflows within the MCP framework
 */
import { ToolExecutionContext } from '../mcp/base-tool-handler';
import { ToolSelectionCriteria, ToolSelectionResult, ToolCapabilityMap, ToolCompatibility, ToolExecutionPlan, ToolExecutionResult, ToolQualityAssessment, ParallelExecutionResult, ExecutionTimeEstimate, LearningStatistics, ToolSelectorConfig } from './types';
/**
 * Intelligent MCP Tool Selection and Execution System
 * Provides smart tool selection algorithms and enhanced execution capabilities
 */
export declare class MCPToolSelector {
    private context;
    private config;
    private capabilityMap;
    private learningData;
    private selectionCache;
    private executionHistory;
    constructor(context: ToolExecutionContext, config?: Partial<ToolSelectorConfig>);
    /**
     * Build comprehensive tool capability map
     */
    buildCapabilityMap(): Promise<ToolCapabilityMap>;
    /**
     * Analyze compatibility between two tools
     */
    analyzeToolCompatibility(tool1: string, tool2: string): Promise<ToolCompatibility>;
    /**
     * Select optimal tool based on criteria
     */
    selectOptimalTool(criteria: ToolSelectionCriteria): Promise<ToolSelectionResult>;
    /**
     * Execute a single tool with enhanced error handling and retries
     */
    executeTool(toolName: string, parameters: Record<string, any>): Promise<ToolExecutionResult>;
    /**
     * Execute multiple tools in parallel
     */
    executeToolsInParallel(tools: Array<{
        toolName: string;
        parameters: Record<string, any>;
    }>): Promise<ParallelExecutionResult>;
    /**
     * Create execution plan for multiple tools
     */
    createExecutionPlan(tools: Array<{
        toolName: string;
        parameters: Record<string, any>;
        priority: number;
        dependencies: string[];
    }>): Promise<ToolExecutionPlan>;
    /**
     * Validate tool result structure and quality
     */
    validateToolResult(toolName: string, result: ToolExecutionResult): Promise<ToolQualityAssessment>;
    /**
     * Assess result quality with custom criteria
     */
    assessResultQuality(toolName: string, result: ToolExecutionResult, criteria?: {
        expectedResultCount?: number;
        relevanceThreshold?: number;
        completenessRequirements?: string[];
    }): Promise<ToolQualityAssessment>;
    /**
     * Learn from tool selection history
     */
    learnFromHistory(history: Array<{
        criteria: any;
        selectedTool: string;
        result: {
            success: boolean;
            qualityScore: number;
        };
    }>): Promise<void>;
    /**
     * Get learning statistics
     */
    getLearningStatistics(): Promise<LearningStatistics>;
    /**
     * Estimate execution time for a tool
     */
    estimateExecutionTime(toolName: string, parameters: Record<string, any>): Promise<ExecutionTimeEstimate>;
    /**
     * Infer parameter types from metadata
     */
    private inferParameterTypes;
    /**
     * Infer output structure from tool name
     */
    private inferOutputStructure;
    /**
     * Parse execution time from metadata
     */
    private parseExecutionTime;
    /**
     * Estimate memory usage based on complexity
     */
    private estimateMemoryUsage;
    /**
     * Infer common use cases from metadata
     */
    private inferUseCases;
    /**
     * Infer best practices from metadata
     */
    private inferBestPractices;
    /**
     * Infer limitations from metadata
     */
    private inferLimitations;
    /**
     * Build tool relationships
     */
    private buildToolRelationships;
    /**
     * Check data flow compatibility between tools
     */
    private checkDataFlowCompatibility;
    /**
     * Calculate compatibility score between tools
     */
    private calculateCompatibilityScore;
    /**
     * Determine execution order for tools
     */
    private determineExecutionOrder;
    /**
     * Generate cache key for criteria
     */
    private generateCacheKey;
    /**
     * Get candidate tools based on criteria
     */
    private getCandidateTools;
    /**
     * Get allowed complexity levels
     */
    private getAllowedComplexities;
    /**
     * Score tool candidates
     */
    private scoreToolCandidates;
    /**
     * Apply selection strategy to scored candidates
     */
    private applySelectionStrategy;
    /**
     * Adaptive selection based on context and learning
     */
    private adaptiveSelection;
    /**
     * Generate suggested parameters for a tool
     */
    private generateSuggestedParameters;
    /**
     * Calculate intent score for a tool
     */
    private calculateIntentScore;
    /**
     * Calculate context score for a tool
     */
    private calculateContextScore;
    /**
     * Get learning score for a tool
     */
    private getLearningScore;
    /**
     * Execute tool internally (simplified implementation)
     */
    private executeToolInternal;
    /**
     * Calculate retry delay with exponential backoff
     */
    private calculateRetryDelay;
    /**
     * Estimate tool execution time
     */
    private estimateToolExecutionTime;
    /**
     * Assess execution risk for tools
     */
    private assessExecutionRisk;
    /**
     * Identify risk factors
     */
    private identifyRiskFactors;
    /**
     * Suggest mitigation strategies
     */
    private suggestMitigationStrategies;
    private calculateRelevanceScore;
    private calculateCompletenessScore;
    private calculateAverageRelevance;
    private calculateDataCompleteness;
    private calculateStructuralIntegrity;
    private generateImprovementSuggestions;
    private calculateParameterComplexity;
    private estimateDataSize;
}