agentic-flow 1.10.1 → 2.0.0-alpha

package/dist/utils/modelCapabilities.js

@@ -1,276 +0,0 @@
-/**
- * Model Capability Detection
- * Determines if a model supports native tool calling or requires emulation
- */
-/**
- * Database of known model capabilities
- * Updated periodically as new models are released
- */
-const MODEL_CAPABILITIES = {
-    // OpenRouter - Native Tool Support
-    'deepseek/deepseek-chat': {
-        supportsNativeTools: true,
-        contextWindow: 128000,
-        requiresEmulation: false,
-        emulationStrategy: 'none',
-        costPerMillionTokens: 0.15
-    },
-    'deepseek/deepseek-chat-v3': {
-        supportsNativeTools: true,
-        contextWindow: 128000,
-        requiresEmulation: false,
-        emulationStrategy: 'none',
-        costPerMillionTokens: 0.15
-    },
-    'meta-llama/llama-3.3-70b-instruct': {
-        supportsNativeTools: true,
-        contextWindow: 128000,
-        requiresEmulation: false,
-        emulationStrategy: 'none',
-        costPerMillionTokens: 0.40
-    },
-    'qwen/qwen-2.5-coder-32b-instruct': {
-        supportsNativeTools: true,
-        contextWindow: 128000,
-        requiresEmulation: false,
-        emulationStrategy: 'none',
-        costPerMillionTokens: 0.23
-    },
-    'mistralai/mistral-small-3.1-24b-instruct': {
-        supportsNativeTools: true,
-        contextWindow: 128000,
-        requiresEmulation: false,
-        emulationStrategy: 'none',
-        costPerMillionTokens: 0.30
-    },
-    // OpenAI Models (via OpenRouter/Requesty)
-    'openai/gpt-4o': {
-        supportsNativeTools: true,
-        contextWindow: 128000,
-        requiresEmulation: false,
-        emulationStrategy: 'none',
-        costPerMillionTokens: 2.50
-    },
-    'openai/gpt-4o-mini': {
-        supportsNativeTools: true,
-        contextWindow: 128000,
-        requiresEmulation: false,
-        emulationStrategy: 'none',
-        costPerMillionTokens: 0.15
-    },
-    'openai/gpt-4-turbo': {
-        supportsNativeTools: true,
-        contextWindow: 128000,
-        requiresEmulation: false,
-        emulationStrategy: 'none',
-        costPerMillionTokens: 10.00
-    },
-    // OpenRouter - No Native Tool Support (Require Emulation)
-    'mistralai/mistral-7b-instruct': {
-        supportsNativeTools: false,
-        contextWindow: 32000,
-        requiresEmulation: true,
-        emulationStrategy: 'react', // Best for this model
-        costPerMillionTokens: 0.07
-    },
-    'meta-llama/llama-2-13b-chat': {
-        supportsNativeTools: false,
-        contextWindow: 4096,
-        requiresEmulation: true,
-        emulationStrategy: 'prompt', // Simple prompting works best
-        costPerMillionTokens: 0.05
-    },
-    'google/gemma-7b-it': {
-        supportsNativeTools: false,
-        contextWindow: 8192,
-        requiresEmulation: true,
-        emulationStrategy: 'prompt',
-        costPerMillionTokens: 0.07
-    },
-    'thudm/glm-4-9b:free': {
-        supportsNativeTools: false, // Free tier limited
-        contextWindow: 32000,
-        requiresEmulation: true,
-        emulationStrategy: 'react',
-        costPerMillionTokens: 0.0 // FREE
-    },
-    // Anthropic - Native Tool Support
-    'claude-3-5-sonnet-20241022': {
-        supportsNativeTools: true,
-        contextWindow: 200000,
-        requiresEmulation: false,
-        emulationStrategy: 'none',
-        costPerMillionTokens: 3.0
-    },
-    'claude-3-5-haiku-20241022': {
-        supportsNativeTools: true,
-        contextWindow: 200000,
-        requiresEmulation: false,
-        emulationStrategy: 'none',
-        costPerMillionTokens: 0.80
-    },
-    // Gemini - Native Tool Support
-    'gemini-2.0-flash-exp': {
-        supportsNativeTools: true,
-        contextWindow: 1000000,
-        requiresEmulation: false,
-        emulationStrategy: 'none',
-        costPerMillionTokens: 0.0 // FREE tier
-    },
-    // OpenAI - Native Tool Support
-    'gpt-4o': {
-        supportsNativeTools: true,
-        contextWindow: 128000,
-        requiresEmulation: false,
-        emulationStrategy: 'none',
-        costPerMillionTokens: 2.50
-    },
-    'gpt-4o-mini': {
-        supportsNativeTools: true,
-        contextWindow: 128000,
-        requiresEmulation: false,
-        emulationStrategy: 'none',
-        costPerMillionTokens: 0.15
-    },
-    'gpt-3.5-turbo': {
-        supportsNativeTools: true,
-        contextWindow: 16385,
-        requiresEmulation: false,
-        emulationStrategy: 'none',
-        costPerMillionTokens: 0.50
-    }
-};
-/**
- * Pattern matching for model families
- */
-const MODEL_PATTERNS = [
-    {
-        pattern: /^claude-3/,
-        capabilities: { supportsNativeTools: true, requiresEmulation: false }
-    },
-    {
-        pattern: /^gpt-(4|3\.5)/,
-        capabilities: { supportsNativeTools: true, requiresEmulation: false }
-    },
-    {
-        pattern: /^gemini-/,
-        capabilities: { supportsNativeTools: true, requiresEmulation: false }
-    },
-    {
-        pattern: /deepseek\/deepseek-(chat|coder)/,
-        capabilities: { supportsNativeTools: true, requiresEmulation: false }
-    },
-    {
-        pattern: /llama-3\.(3|2|1)-.*instruct/,
-        capabilities: { supportsNativeTools: true, requiresEmulation: false }
-    },
-    {
-        pattern: /qwen.*2\.5/,
-        capabilities: { supportsNativeTools: true, requiresEmulation: false }
-    },
-    {
-        pattern: /mistral.*large|mistral.*small/,
-        capabilities: { supportsNativeTools: true, requiresEmulation: false }
-    },
-    // Older models typically don't support tools
-    {
-        pattern: /llama-2|mistral-7b|gemma-.*7b/,
-        capabilities: { supportsNativeTools: false, requiresEmulation: true, emulationStrategy: 'react' }
-    }
-];
-/**
- * Detect capabilities of a model
- */
-export function detectModelCapabilities(modelId) {
-    // Direct lookup
-    if (MODEL_CAPABILITIES[modelId]) {
-        return {
-            supportsNativeTools: false,
-            supportsStreaming: true,
-            contextWindow: 4096,
-            requiresEmulation: true,
-            emulationStrategy: 'prompt',
-            costPerMillionTokens: 0.5,
-            provider: 'unknown',
-            ...MODEL_CAPABILITIES[modelId]
-        };
-    }
-    // Pattern matching
-    for (const { pattern, capabilities } of MODEL_PATTERNS) {
-        if (pattern.test(modelId)) {
-            return {
-                supportsNativeTools: false,
-                supportsStreaming: true,
-                contextWindow: 4096,
-                requiresEmulation: true,
-                emulationStrategy: 'prompt',
-                costPerMillionTokens: 0.5,
-                provider: 'unknown',
-                ...capabilities
-            };
-        }
-    }
-    // Unknown model - assume needs emulation (conservative)
-    console.warn(`⚠️  Unknown model: ${modelId}. Assuming no native tool support.`);
-    return {
-        supportsNativeTools: false,
-        supportsStreaming: true,
-        contextWindow: 4096,
-        requiresEmulation: true,
-        emulationStrategy: 'prompt',
-        costPerMillionTokens: 0.5,
-        provider: 'unknown'
-    };
-}
-/**
- * Check if model can handle a specific number of tools
- */
-export function canHandleToolCount(modelId, toolCount) {
-    const capabilities = detectModelCapabilities(modelId);
-    // Estimate: Each tool ~100 tokens of schema
-    const estimatedTokens = toolCount * 100;
-    // Need at least 20% of context window free for actual conversation
-    const maxToolTokens = capabilities.contextWindow * 0.8;
-    return estimatedTokens <= maxToolTokens;
-}
-/**
- * Recommend optimal strategy for a model
- */
-export function recommendStrategy(modelId, toolCount, taskComplexity) {
-    const capabilities = detectModelCapabilities(modelId);
-    if (capabilities.supportsNativeTools) {
-        return 'native';
-    }
-    // For emulation, choose based on context and complexity
-    if (toolCount > 10 || taskComplexity === 'complex') {
-        return 'react'; // More robust for complex scenarios
-    }
-    if (capabilities.contextWindow < 8000) {
-        return 'prompt'; // Simpler for small context windows
-    }
-    return 'react'; // Default to ReAct pattern
-}
-/**
- * Get human-readable capability report
- */
-export function getCapabilityReport(modelId) {
-    const cap = detectModelCapabilities(modelId);
-    let report = `\n📊 Model Capabilities: ${modelId}\n`;
-    report += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
-    report += `Native Tool Support:  ${cap.supportsNativeTools ? '✅ Yes' : '❌ No'}\n`;
-    report += `Context Window:       ${cap.contextWindow.toLocaleString()} tokens\n`;
-    report += `Streaming:            ${cap.supportsStreaming ? '✅ Yes' : '❌ No'}\n`;
-    report += `Cost per 1M tokens:   $${cap.costPerMillionTokens}\n`;
-    if (cap.requiresEmulation) {
-        report += `\n⚙️  Emulation Required\n`;
-        report += `Recommended Strategy: ${cap.emulationStrategy.toUpperCase()}\n`;
-        report += `\nNote: This model will use prompt-based tool emulation.\n`;
-        report += `Expect 70-85% reliability vs 95%+ for native tool support.\n`;
-    }
-    else {
-        report += `\n✅ No Emulation Needed\n`;
-        report += `This model natively supports function calling.\n`;
-    }
-    report += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
-    return report;
-}

package/dist/utils/modelOptimizer.js

@@ -1,414 +0,0 @@
-/**
- * Smart Model Optimizer - Automatically selects the best model for each agent and task
- * Balances performance vs cost based on agent requirements
- */
-import { logger } from './logger.js';
-// Model database with performance characteristics
-const MODEL_DATABASE = {
-    // Tier 1: Flagship Models
-    'claude-sonnet-4-5': {
-        provider: 'anthropic',
-        model: 'claude-sonnet-4-5-20250929',
-        modelName: 'Claude Sonnet 4.5',
-        cost_per_1m_input: 3.00,
-        cost_per_1m_output: 15.00,
-        quality_score: 95,
-        speed_score: 85,
-        cost_score: 20,
-        tier: 'flagship',
-        supports_tools: true,
-        strengths: ['reasoning', 'coding', 'analysis', 'production'],
-        weaknesses: ['cost'],
-        bestFor: ['coder', 'reviewer', 'architecture', 'planner', 'production-validator']
-    },
-    'gpt-4o': {
-        provider: 'openrouter',
-        model: 'openai/gpt-4o',
-        modelName: 'GPT-4o',
-        cost_per_1m_input: 2.50,
-        cost_per_1m_output: 10.00,
-        quality_score: 88,
-        speed_score: 90,
-        cost_score: 30,
-        tier: 'flagship',
-        supports_tools: true,
-        strengths: ['multimodal', 'speed', 'general-purpose', 'vision'],
-        weaknesses: ['cost'],
-        bestFor: ['researcher', 'analyst', 'multimodal-tasks']
-    },
-    'gemini-2-5-pro': {
-        provider: 'openrouter',
-        model: 'google/gemini-2.5-pro',
-        modelName: 'Gemini 2.5 Pro',
-        cost_per_1m_input: 1.25,
-        cost_per_1m_output: 5.00,
-        quality_score: 90,
-        speed_score: 75,
-        cost_score: 50,
-        tier: 'flagship',
-        supports_tools: true,
-        strengths: ['reasoning', 'large-context', 'math', 'analysis'],
-        weaknesses: ['speed'],
-        bestFor: ['planner', 'architecture', 'researcher', 'code-analyzer']
-    },
-    // Tier 2: Cost-Effective Champions
-    'deepseek-r1': {
-        provider: 'openrouter',
-        model: 'deepseek/deepseek-r1-0528:free',
-        modelName: 'DeepSeek R1',
-        cost_per_1m_input: 0.00,
-        cost_per_1m_output: 0.00,
-        quality_score: 90,
-        speed_score: 80,
-        cost_score: 100,
-        tier: 'cost-effective',
-        supports_tools: false, // DeepSeek R1 does NOT support tool/function calling
-        strengths: ['reasoning', 'coding', 'math', 'value', 'free'],
-        weaknesses: ['newer-model', 'no-tool-use'],
-        bestFor: ['coder', 'pseudocode', 'specification', 'refinement', 'tester']
-    },
-    'deepseek-chat-v3': {
-        provider: 'openrouter',
-        model: 'deepseek/deepseek-chat-v3.1:free',
-        modelName: 'DeepSeek Chat V3.1',
-        cost_per_1m_input: 0.00,
-        cost_per_1m_output: 0.00,
-        quality_score: 82,
-        speed_score: 90,
-        cost_score: 100,
-        tier: 'cost-effective',
-        supports_tools: true,
-        strengths: ['cost', 'speed', 'coding', 'development', 'free'],
-        weaknesses: ['complex-reasoning'],
-        bestFor: ['coder', 'reviewer', 'tester', 'backend-dev', 'cicd-engineer']
-    },
-    // Tier 3: Balanced Performance
-    'gemini-2-5-flash': {
-        provider: 'openrouter',
-        model: 'google/gemini-2.5-flash',
-        modelName: 'Gemini 2.5 Flash',
-        cost_per_1m_input: 0.075,
-        cost_per_1m_output: 0.30,
-        quality_score: 78,
-        speed_score: 98,
-        cost_score: 98,
-        tier: 'balanced',
-        supports_tools: true,
-        strengths: ['speed', 'cost', 'interactive'],
-        weaknesses: ['quality'],
-        bestFor: ['researcher', 'planner', 'smart-agent']
-    },
-    'llama-3-3-8b': {
-        provider: 'openrouter',
-        model: 'meta-llama/llama-3.3-8b-instruct:free',
-        modelName: 'Llama 3.3 8B',
-        cost_per_1m_input: 0.00,
-        cost_per_1m_output: 0.00,
-        quality_score: 72,
-        speed_score: 95,
-        cost_score: 100,
-        tier: 'balanced',
-        supports_tools: true,
-        strengths: ['open-source', 'versatile', 'coding', 'free', 'fast'],
-        weaknesses: ['smaller-model'],
-        bestFor: ['coder', 'reviewer', 'base-template-generator', 'tester']
-    },
-    'qwen-2-5-72b': {
-        provider: 'openrouter',
-        model: 'qwen/qwen-2.5-72b-instruct',
-        modelName: 'Qwen 2.5 72B',
-        cost_per_1m_input: 0.35,
-        cost_per_1m_output: 0.40,
-        quality_score: 81,
-        speed_score: 85,
-        cost_score: 90,
-        tier: 'balanced',
-        supports_tools: true,
-        strengths: ['multilingual', 'coding', 'reasoning'],
-        weaknesses: ['english-optimized'],
-        bestFor: ['researcher', 'coder', 'multilingual-tasks']
-    },
-    // Tier 4: Budget Options
-    'llama-3-1-8b': {
-        provider: 'openrouter',
-        model: 'meta-llama/llama-3.1-8b-instruct',
-        modelName: 'Llama 3.1 8B',
-        cost_per_1m_input: 0.06,
-        cost_per_1m_output: 0.06,
-        quality_score: 65,
-        speed_score: 95,
-        cost_score: 99,
-        tier: 'budget',
-        supports_tools: true,
-        strengths: ['ultra-low-cost', 'speed'],
-        weaknesses: ['quality', 'complex-tasks'],
-        bestFor: ['simple-tasks', 'testing']
-    },
-    // Tier 5: Local/Privacy
-    'onnx-phi-4': {
-        provider: 'onnx',
-        model: 'phi-4-mini',
-        modelName: 'ONNX Phi-4 Mini',
-        cost_per_1m_input: 0.00,
-        cost_per_1m_output: 0.00,
-        quality_score: 58,
-        speed_score: 30,
-        cost_score: 100,
-        tier: 'local',
-        supports_tools: false,
-        strengths: ['privacy', 'offline', 'zero-cost'],
-        weaknesses: ['quality', 'speed'],
-        bestFor: ['privacy-tasks', 'offline-tasks']
-    }
-};
-// Agent complexity and quality requirements
-const AGENT_REQUIREMENTS = {
-    // High-quality code generation
-    'coder': { minQuality: 85, complexity: 'complex', needsReasoning: true },
-    'sparc-coder': { minQuality: 85, complexity: 'complex', needsReasoning: true },
-    'backend-dev': { minQuality: 80, complexity: 'complex', needsReasoning: true },
-    // Architecture and design
-    'architecture': { minQuality: 90, complexity: 'expert', needsReasoning: true },
-    'system-architect': { minQuality: 90, complexity: 'expert', needsReasoning: true },
-    'planner': { minQuality: 85, complexity: 'complex', needsReasoning: true },
-    // Code review and analysis
-    'reviewer': { minQuality: 85, complexity: 'complex', needsReasoning: true },
-    'code-analyzer': { minQuality: 80, complexity: 'complex', needsReasoning: true },
-    'production-validator': { minQuality: 90, complexity: 'expert', needsReasoning: true },
-    // Testing
-    'tester': { minQuality: 75, complexity: 'moderate', needsReasoning: false },
-    'tdd-london-swarm': { minQuality: 80, complexity: 'complex', needsReasoning: true },
-    // Research and analysis
-    'researcher': { minQuality: 75, complexity: 'moderate', needsReasoning: true },
-    'analyst': { minQuality: 80, complexity: 'complex', needsReasoning: true },
-    // SPARC phases
-    'specification': { minQuality: 85, complexity: 'complex', needsReasoning: true },
-    'pseudocode': { minQuality: 80, complexity: 'complex', needsReasoning: true },
-    'refinement': { minQuality: 85, complexity: 'complex', needsReasoning: true },
-    // DevOps and automation
-    'cicd-engineer': { minQuality: 75, complexity: 'moderate', needsReasoning: false },
-    'smart-agent': { minQuality: 70, complexity: 'moderate', needsReasoning: false },
-    // Documentation
-    'api-docs': { minQuality: 70, complexity: 'moderate', needsReasoning: false },
-    'base-template-generator': { minQuality: 70, complexity: 'simple', needsReasoning: false },
-    // Default for unknown agents
-    'default': { minQuality: 75, complexity: 'moderate', needsReasoning: true }
-};
-export class ModelOptimizer {
-    /**
-     * Optimize model selection based on agent, task, and priorities
-     */
-    static optimize(criteria) {
-        logger.info('Optimizing model selection', criteria);
-        // Get agent requirements
-        const agentKey = criteria.agent.toLowerCase();
-        const agentReqs = AGENT_REQUIREMENTS[agentKey] || AGENT_REQUIREMENTS['default'];
-        // Determine task complexity from task description if not provided
-        const taskComplexity = criteria.taskComplexity || this.inferComplexity(criteria.task);
-        // Set default priority to balanced if not specified
-        const priority = criteria.priority || 'balanced';
-        // Filter models that support tools if required
-        let availableModels = Object.entries(MODEL_DATABASE);
-        if (criteria.requiresTools) {
-            availableModels = availableModels.filter(([key, model]) => model.supports_tools !== false);
-            logger.info(`Filtered to ${availableModels.length} models with tool support`);
-        }
-        // Score all models
-        const scoredModels = availableModels.map(([key, model]) => {
-            // Calculate overall score based on priority
-            let overall_score;
-            switch (priority) {
-                case 'quality':
-                    overall_score = model.quality_score * 0.7 + model.speed_score * 0.2 + model.cost_score * 0.1;
-                    break;
-                case 'cost':
-                    overall_score = model.cost_score * 0.7 + model.quality_score * 0.2 + model.speed_score * 0.1;
-                    break;
-                case 'speed':
-                    overall_score = model.speed_score * 0.7 + model.quality_score * 0.2 + model.cost_score * 0.1;
-                    break;
-                case 'privacy':
-                    // Heavily favor local models for privacy
-                    overall_score = model.tier === 'local' ? 100 : model.cost_score * 0.5 + model.quality_score * 0.5;
-                    break;
-                case 'balanced':
-                default:
-                    overall_score = model.quality_score * 0.4 + model.cost_score * 0.4 + model.speed_score * 0.2;
-                    break;
-            }
-            // Apply agent-specific bonuses
-            if (model.bestFor.includes(criteria.agent.toLowerCase())) {
-                overall_score += 10;
-            }
-            // Apply quality threshold
-            if (model.quality_score < agentReqs.minQuality) {
-                overall_score *= 0.5; // Penalize models below quality threshold
-            }
-            // Apply complexity matching
-            if (taskComplexity === 'expert' && model.tier !== 'flagship') {
-                overall_score *= 0.7;
-            }
-            else if (taskComplexity === 'simple' && model.tier === 'flagship') {
-                overall_score *= 0.8; // Don't waste flagship models on simple tasks unless quality priority
-            }
-            // Apply cost cap if specified
-            if (criteria.maxCostPerTask) {
-                const estimatedCost = this.estimateCost(model, criteria.task);
-                if (estimatedCost > criteria.maxCostPerTask) {
-                    overall_score *= 0.3; // Heavy penalty for exceeding budget
-                }
-            }
-            return {
-                key,
-                ...model,
-                overall_score
-            };
-        });
-        // Sort by overall score
-        scoredModels.sort((a, b) => b.overall_score - a.overall_score);
-        // Get top recommendation
-        const top = scoredModels[0];
-        // Generate reasoning
-        const reasoning = this.generateReasoning(top, criteria, agentReqs, taskComplexity, priority);
-        const recommendation = {
-            provider: top.provider,
-            model: top.model,
-            modelName: top.modelName,
-            cost_per_1m_input: top.cost_per_1m_input,
-            cost_per_1m_output: top.cost_per_1m_output,
-            quality_score: top.quality_score,
-            speed_score: top.speed_score,
-            cost_score: top.cost_score,
-            overall_score: top.overall_score,
-            tier: top.tier,
-            reasoning
-        };
-        logger.info('Model optimization complete', {
-            selected: recommendation.modelName,
-            score: recommendation.overall_score
-        });
-        return recommendation;
-    }
-    /**
-     * Infer task complexity from task description
-     */
-    static inferComplexity(task) {
-        const lowerTask = task.toLowerCase();
-        // Expert-level indicators
-        if (lowerTask.includes('architecture') ||
-            lowerTask.includes('design system') ||
-            lowerTask.includes('production') ||
-            lowerTask.includes('enterprise') ||
-            lowerTask.includes('scale') ||
-            lowerTask.includes('distributed')) {
-            return 'expert';
-        }
-        // Complex indicators
-        if (lowerTask.includes('implement') ||
-            lowerTask.includes('create') ||
-            lowerTask.includes('build') ||
-            lowerTask.includes('develop') ||
-            lowerTask.includes('integrate') ||
-            lowerTask.includes('api') ||
-            lowerTask.includes('database')) {
-            return 'complex';
-        }
-        // Simple indicators
-        if (lowerTask.includes('simple') ||
-            lowerTask.includes('basic') ||
-            lowerTask.includes('hello world') ||
-            lowerTask.includes('example') ||
-            lowerTask.includes('template')) {
-            return 'simple';
-        }
-        // Default to moderate
-        return 'moderate';
-    }
-    /**
-     * Estimate cost for a task (rough approximation)
-     */
-    static estimateCost(model, task) {
-        // Rough estimate: task length + expected output
-        const inputTokens = Math.ceil(task.length / 4);
-        const outputTokens = 1000; // Assume 1K token output
-        const inputCost = (inputTokens / 1000000) * model.cost_per_1m_input;
-        const outputCost = (outputTokens / 1000000) * model.cost_per_1m_output;
-        return inputCost + outputCost;
-    }
-    /**
-     * Generate human-readable reasoning for model selection
-     */
-    static generateReasoning(model, criteria, agentReqs, taskComplexity, priority) {
-        const reasons = [];
-        // Priority-based reasoning
-        switch (priority) {
-            case 'quality':
-                reasons.push(`Selected for highest quality (${model.quality_score}/100)`);
-                break;
-            case 'cost':
-                reasons.push(`Selected for best cost efficiency (${model.cost_score}/100)`);
-                break;
-            case 'speed':
-                reasons.push(`Selected for fastest response (${model.speed_score}/100)`);
-                break;
-            case 'privacy':
-                if (model.tier === 'local') {
-                    reasons.push('Selected for 100% privacy (runs locally)');
-                }
-                else {
-                    reasons.push('Best available option for privacy concerns');
-                }
-                break;
-            case 'balanced':
-                reasons.push(`Balanced selection (overall: ${Math.round(model.overall_score)}/100)`);
-                break;
-        }
-        // Agent-specific reasoning
-        if (model.bestFor.includes(criteria.agent.toLowerCase())) {
-            reasons.push(`Optimized for ${criteria.agent} agent tasks`);
-        }
-        // Complexity matching
-        if (taskComplexity === 'expert' && model.tier === 'flagship') {
-            reasons.push('Flagship model for expert-level complexity');
-        }
-        else if (taskComplexity === 'simple' && model.tier !== 'flagship') {
-            reasons.push('Cost-effective for simple tasks');
-        }
-        // Cost information
-        const estCost = this.estimateCost(model, criteria.task);
-        reasons.push(`Estimated cost: $${estCost.toFixed(6)} per task`);
-        // Tier information
-        reasons.push(`Tier: ${model.tier}`);
-        return reasons.join('. ');
-    }
-    /**
-     * Get all available models with their characteristics
-     */
-    static getAvailableModels() {
-        return MODEL_DATABASE;
-    }
-    /**
-     * Display optimization recommendations in console
-     */
-    static displayRecommendation(recommendation) {
-        console.log('\n🎯 Optimized Model Selection');
-        console.log('═'.repeat(60));
-        console.log(`Model: ${recommendation.modelName}`);
-        console.log(`Provider: ${recommendation.provider}`);
-        console.log(`Tier: ${recommendation.tier}`);
-        console.log('');
-        console.log('Scores:');
-        console.log(`  Quality:  ${recommendation.quality_score}/100`);
-        console.log(`  Speed:    ${recommendation.speed_score}/100`);
-        console.log(`  Cost:     ${recommendation.cost_score}/100`);
-        console.log(`  Overall:  ${Math.round(recommendation.overall_score)}/100`);
-        console.log('');
-        console.log('Cost: $' + recommendation.cost_per_1m_input.toFixed(2) + '/1M input, ' +
-            '$' + recommendation.cost_per_1m_output.toFixed(2) + '/1M output');
-        console.log('');
-        console.log('Reasoning:');
-        console.log(`  ${recommendation.reasoning}`);
-        console.log('═'.repeat(60));
-        console.log('');
-    }
-}