@llm-dev-ops/agentics-cli 1.4.26 → 1.4.29

package/dist/bundled-agents/auto-optimizer-agents/dist/agents/model-selection-agent/index.js

@@ -0,0 +1,896 @@
+"use strict";
+/**
+ * Model Selection Agent
+ *
+ * A RECOMMENDATION agent that recommends optimal model selection based on
+ * historical performance signals, task context, and constraints.
+ *
+ * Classification: RECOMMENDATION
+ * Decision Type: model_selection_recommendation
+ *
+ * This agent:
+ * - Analyzes cost, latency, and quality metrics by model
+ * - Proposes alternative model candidates with scoring
+ * - Emits advisory-only selection guidance
+ *
+ * This agent MUST NOT:
+ * - Route traffic directly
+ * - Enforce model selection
+ * - Modify execution paths
+ * - Execute optimizations directly
+ * - Modify runtime behavior autonomously
+ * - Intercept execution traffic
+ * - Trigger retries
+ * - Emit alerts (that is Sentinel)
+ * - Enforce policies (that is Shield)
+ * - Perform orchestration (that is LLM-Orchestrator)
+ *
+ * @module agents/model-selection-agent
+ * @version 1.0.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelSelectionAgent = exports.DECISION_TYPE = exports.AGENT_VERSION = exports.AGENT_ID = void 0;
+exports.createModelSelectionAgent = createModelSelectionAgent;
+const contracts_1 = require("../../contracts");
+const ruvector_client_1 = require("../../services/ruvector-client");
+// ============================================================================
+// Constants
+// ============================================================================
+exports.AGENT_ID = 'model-selection-agent';
+exports.AGENT_VERSION = '1.0.0';
+exports.DECISION_TYPE = 'model_selection_recommendation';
+// Model cost data (from provider pricing as of 2024)
+const MODEL_COSTS = {
+    'claude-3-opus': { input: 0.015, output: 0.075 },
+    'claude-3-5-sonnet': { input: 0.003, output: 0.015 },
+    'claude-3-sonnet': { input: 0.003, output: 0.015 },
+    'claude-3-haiku': { input: 0.00025, output: 0.00125 },
+    'gpt-4o': { input: 0.005, output: 0.015 },
+    'gpt-4-turbo': { input: 0.01, output: 0.03 },
+    'gpt-4': { input: 0.03, output: 0.06 },
+    'gpt-3.5-turbo': { input: 0.0005, output: 0.0015 },
+    'gemini-1.5-pro': { input: 0.00125, output: 0.005 },
+    'gemini-1.5-flash': { input: 0.000075, output: 0.0003 },
+};
+// Quality benchmarks (0-1 scale based on standard benchmarks)
+const QUALITY_BENCHMARKS = {
+    'claude-3-opus': 0.95,
+    'claude-3-5-sonnet': 0.93,
+    'claude-3-sonnet': 0.90,
+    'claude-3-haiku': 0.82,
+    'gpt-4o': 0.92,
+    'gpt-4-turbo': 0.91,
+    'gpt-4': 0.93,
+    'gpt-3.5-turbo': 0.75,
+    'gemini-1.5-pro': 0.91,
+    'gemini-1.5-flash': 0.80,
+};
+// Average latency benchmarks (P95 in ms)
+const LATENCY_BENCHMARKS = {
+    'claude-3-opus': 3000,
+    'claude-3-5-sonnet': 1500,
+    'claude-3-sonnet': 1200,
+    'claude-3-haiku': 400,
+    'gpt-4o': 1000,
+    'gpt-4-turbo': 2000,
+    'gpt-4': 3500,
+    'gpt-3.5-turbo': 500,
+    'gemini-1.5-pro': 1800,
+    'gemini-1.5-flash': 350,
+};
+// Task type to model capability mapping (suitability scores)
+const TASK_MODEL_SUITABILITY = {
+    'code_generation': {
+        'claude-3-opus': 0.98,
+        'claude-3-5-sonnet': 0.96,
+        'claude-3-sonnet': 0.90,
+        'claude-3-haiku': 0.75,
+        'gpt-4o': 0.94,
+        'gpt-4-turbo': 0.92,
+        'gpt-4': 0.93,
+        'gpt-3.5-turbo': 0.70,
+        'gemini-1.5-pro': 0.88,
+        'gemini-1.5-flash': 0.72,
+    },
+    'code_review': {
+        'claude-3-opus': 0.97,
+        'claude-3-5-sonnet': 0.95,
+        'claude-3-sonnet': 0.88,
+        'claude-3-haiku': 0.70,
+        'gpt-4o': 0.92,
+        'gpt-4-turbo': 0.90,
+        'gpt-4': 0.91,
+        'gpt-3.5-turbo': 0.65,
+        'gemini-1.5-pro': 0.86,
+        'gemini-1.5-flash': 0.68,
+    },
+    'reasoning': {
+        'claude-3-opus': 0.98,
+        'claude-3-5-sonnet': 0.94,
+        'claude-3-sonnet': 0.85,
+        'claude-3-haiku': 0.65,
+        'gpt-4o': 0.92,
+        'gpt-4-turbo': 0.88,
+        'gpt-4': 0.93,
+        'gpt-3.5-turbo': 0.60,
+        'gemini-1.5-pro': 0.90,
+        'gemini-1.5-flash': 0.62,
+    },
+    'creative_writing': {
+        'claude-3-opus': 0.96,
+        'claude-3-5-sonnet': 0.94,
+        'claude-3-sonnet': 0.90,
+        'claude-3-haiku': 0.72,
+        'gpt-4o': 0.90,
+        'gpt-4-turbo': 0.88,
+        'gpt-4': 0.91,
+        'gpt-3.5-turbo': 0.70,
+        'gemini-1.5-pro': 0.85,
+        'gemini-1.5-flash': 0.68,
+    },
+    'text_summarization': {
+        'claude-3-opus': 0.92,
+        'claude-3-5-sonnet': 0.90,
+        'claude-3-sonnet': 0.88,
+        'claude-3-haiku': 0.80,
+        'gpt-4o': 0.88,
+        'gpt-4-turbo': 0.85,
+        'gpt-4': 0.87,
+        'gpt-3.5-turbo': 0.75,
+        'gemini-1.5-pro': 0.86,
+        'gemini-1.5-flash': 0.78,
+    },
+    'question_answering': {
+        'claude-3-opus': 0.95,
+        'claude-3-5-sonnet': 0.93,
+        'claude-3-sonnet': 0.88,
+        'claude-3-haiku': 0.78,
+        'gpt-4o': 0.91,
+        'gpt-4-turbo': 0.88,
+        'gpt-4': 0.90,
+        'gpt-3.5-turbo': 0.72,
+        'gemini-1.5-pro': 0.87,
+        'gemini-1.5-flash': 0.75,
+    },
+    'data_extraction': {
+        'claude-3-opus': 0.92,
+        'claude-3-5-sonnet': 0.90,
+        'claude-3-sonnet': 0.86,
+        'claude-3-haiku': 0.82,
+        'gpt-4o': 0.88,
+        'gpt-4-turbo': 0.86,
+        'gpt-4': 0.87,
+        'gpt-3.5-turbo': 0.78,
+        'gemini-1.5-pro': 0.85,
+        'gemini-1.5-flash': 0.80,
+    },
+    'classification': {
+        'claude-3-opus': 0.88,
+        'claude-3-5-sonnet': 0.86,
+        'claude-3-sonnet': 0.84,
+        'claude-3-haiku': 0.82,
+        'gpt-4o': 0.86,
+        'gpt-4-turbo': 0.84,
+        'gpt-4': 0.85,
+        'gpt-3.5-turbo': 0.80,
+        'gemini-1.5-pro': 0.83,
+        'gemini-1.5-flash': 0.80,
+    },
+    'general': {
+        'claude-3-opus': 0.94,
+        'claude-3-5-sonnet': 0.92,
+        'claude-3-sonnet': 0.87,
+        'claude-3-haiku': 0.75,
+        'gpt-4o': 0.90,
+        'gpt-4-turbo': 0.87,
+        'gpt-4': 0.89,
+        'gpt-3.5-turbo': 0.72,
+        'gemini-1.5-pro': 0.86,
+        'gemini-1.5-flash': 0.73,
+    },
+};
+// Model provider mapping
+const MODEL_PROVIDERS = {
+    'claude-3-opus': 'anthropic',
+    'claude-3-5-sonnet': 'anthropic',
+    'claude-3-sonnet': 'anthropic',
+    'claude-3-haiku': 'anthropic',
+    'gpt-4o': 'openai',
+    'gpt-4-turbo': 'openai',
+    'gpt-4': 'openai',
+    'gpt-3.5-turbo': 'openai',
+    'gemini-1.5-pro': 'google',
+    'gemini-1.5-flash': 'google',
+};
+const DEFAULT_CONFIG = {
+    ruVectorClient: undefined,
+    enableTelemetry: true,
+    telemetryEndpoint: process.env.TELEMETRY_ENDPOINT || '',
+    maxAlternatives: 5,
+    minConfidenceThreshold: 0.5,
+};
+// ============================================================================
+// Model Selection Agent Class
+// ============================================================================
+/**
+ * Model Selection Agent - Recommends optimal model selection.
+ *
+ * This is a stateless, deterministic agent designed to run as a
+ * Google Cloud Edge Function.
+ */
+class ModelSelectionAgent {
+    config;
+    ruVectorClient;
+    constructor(config = {}) {
+        this.config = {
+            ...DEFAULT_CONFIG,
+            ...config,
+        };
+        // Initialize RuVector client
+        this.ruVectorClient = this.config.ruVectorClient || (0, ruvector_client_1.createRuVectorClient)();
+    }
+    // --------------------------------------------------------------------------
+    // Public API - CLI Invocable Endpoints
+    // --------------------------------------------------------------------------
+    /**
+     * ANALYZE - Perform analysis without generating recommendations.
+     * Use this for understanding current model landscape and capabilities.
+     */
+    async analyze(input) {
+        return this.execute(input, 'analyze');
+    }
+    /**
+     * RECOMMEND - Generate model selection recommendations.
+     * Primary entry point for the agent.
+     */
+    async recommend(input) {
+        return this.execute(input, 'recommend');
+    }
+    /**
+     * SIMULATE - Simulate model selection without persisting.
+     * Use for what-if analysis with different task contexts.
+     */
+    async simulate(input) {
+        return this.execute(input, 'simulate');
+    }
+    // --------------------------------------------------------------------------
+    // Core Execution Logic
+    // --------------------------------------------------------------------------
+    async execute(input, mode) {
+        const startTime = Date.now();
+        // Step 1: Validate input against schema
+        (0, contracts_1.validateModelSelectionInput)(input);
+        // Step 2: Compute inputs hash for reproducibility
+        const inputsHash = (0, contracts_1.hashInputs)(input);
+        // Step 3: Get all available models
+        const availableModels = this.getAvailableModels(input.performance_history);
+        // Step 4: Filter models by constraints
+        const constraintResults = this.evaluateConstraints(availableModels, input.constraints, input.task_context);
+        const eligibleModels = constraintResults.eligibleModels;
+        // Step 5: Score eligible models
+        const scoredModels = this.scoreModels(eligibleModels, input.task_context, input.performance_history);
+        // Step 6: Build recommendations
+        const recommendations = mode === 'analyze'
+            ? []
+            : this.buildRecommendations(scoredModels, input);
+        // Step 7: Build analysis summary
+        const analysisSummary = this.buildAnalysisSummary(availableModels, eligibleModels, scoredModels, input.task_context);
+        // Step 8: Build output
+        const output = this.buildOutput(input, recommendations, analysisSummary, constraintResults.evaluations, availableModels, startTime);
+        // Step 9: Validate output
+        (0, contracts_1.validateModelSelectionOutput)(output);
+        // Step 10: Build and persist DecisionEvent (skip for simulate mode)
+        if (mode !== 'simulate') {
+            const decisionEvent = this.buildDecisionEvent(input, output, inputsHash, constraintResults.evaluations);
+            // Persist to ruvector-service (non-blocking)
+            try {
+                await this.ruVectorClient.persistDecisionEvent(decisionEvent);
+            }
+            catch (persistErr) {
+                console.warn('[ModelSelectionAgent] RuVector persistence failed (non-blocking):', persistErr instanceof Error ? persistErr.message : persistErr);
+            }
+            // Step 11: Emit telemetry (if enabled)
+            if (this.config.enableTelemetry) {
+                await this.emitTelemetry(decisionEvent, output, Date.now() - startTime);
+            }
+        }
+        return output;
+    }
+    // --------------------------------------------------------------------------
+    // Model Discovery
+    // --------------------------------------------------------------------------
+    getAvailableModels(history) {
+        // Start with known models from benchmarks
+        const models = new Set(Object.keys(MODEL_COSTS));
+        // Add models from historical data
+        for (const modelId of Object.keys(history.by_model)) {
+            models.add(modelId);
+        }
+        return Array.from(models);
+    }
+    // --------------------------------------------------------------------------
+    // Constraint Evaluation
+    // --------------------------------------------------------------------------
+    evaluateConstraints(models, constraints, context) {
+        let eligibleModels = [...models];
+        const evaluations = [];
+        for (const constraint of constraints) {
+            const beforeCount = eligibleModels.length;
+            const passingModels = [];
+            for (const model of eligibleModels) {
+                if (this.modelPassesConstraint(model, constraint, context)) {
+                    passingModels.push(model);
+                }
+            }
+            const blockedCount = beforeCount - passingModels.length;
+            evaluations.push({
+                constraint,
+                satisfied: constraint.hard ? passingModels.length > 0 : true,
+                models_passing: passingModels.length,
+                models_blocked: blockedCount,
+                impact_description: blockedCount > 0
+                    ? `Blocked ${blockedCount} models: ${constraint.type} = ${JSON.stringify(constraint.value)}`
+                    : 'No models blocked',
+            });
+            // Apply hard constraints immediately
+            if (constraint.hard) {
+                eligibleModels = passingModels;
+            }
+        }
+        return { eligibleModels, evaluations };
+    }
+    modelPassesConstraint(model, constraint, context) {
+        switch (constraint.type) {
+            case 'allowed_models': {
+                const allowed = Array.isArray(constraint.value)
+                    ? constraint.value
+                    : String(constraint.value).split(',');
+                return allowed.includes(model);
+            }
+            case 'blocked_models': {
+                const blocked = Array.isArray(constraint.value)
+                    ? constraint.value
+                    : String(constraint.value).split(',');
+                return !blocked.includes(model);
+            }
+            case 'allowed_providers': {
+                const providers = Array.isArray(constraint.value)
+                    ? constraint.value
+                    : String(constraint.value).split(',');
+                return providers.includes(MODEL_PROVIDERS[model] || '');
+            }
+            case 'blocked_providers': {
+                const providers = Array.isArray(constraint.value)
+                    ? constraint.value
+                    : String(constraint.value).split(',');
+                return !providers.includes(MODEL_PROVIDERS[model] || '');
+            }
+            case 'max_cost_per_request': {
+                const maxCost = Number(constraint.value);
+                const cost = this.estimateCostPerRequest(model, context);
+                return cost <= maxCost;
+            }
+            case 'min_quality_threshold': {
+                const minQuality = Number(constraint.value);
+                const quality = QUALITY_BENCHMARKS[model] || 0.7;
+                return quality >= minQuality;
+            }
+            case 'max_latency_ms': {
+                const maxLatency = Number(constraint.value);
+                const latency = LATENCY_BENCHMARKS[model] || 2000;
+                return latency <= maxLatency;
+            }
+            default:
+                return true;
+        }
+    }
+    estimateCostPerRequest(model, context) {
+        const costs = MODEL_COSTS[model];
+        if (!costs)
+            return 0.1; // Default fallback
+        const avgInputTokens = context.expected_input_tokens.avg ||
+            (context.expected_input_tokens.min + context.expected_input_tokens.max) / 2;
+        const avgOutputTokens = context.expected_output_tokens.avg ||
+            (context.expected_output_tokens.min + context.expected_output_tokens.max) / 2;
+        return (avgInputTokens / 1000) * costs.input + (avgOutputTokens / 1000) * costs.output;
+    }
+    // --------------------------------------------------------------------------
+    // Model Scoring
+    // --------------------------------------------------------------------------
+    scoreModels(models, context, history) {
+        const scoredModels = [];
+        // Determine weights based on task context
+        const weights = this.determineWeights(context);
+        for (const model of models) {
+            const scores = this.calculateModelScores(model, context, history);
+            const totalScore = scores.quality_score * weights.quality +
+                scores.latency_score * weights.latency +
+                scores.cost_score * weights.cost +
+                scores.task_fit_score * weights.task_fit +
+                scores.reliability_score * weights.reliability;
+            scoredModels.push({
+                model,
+                totalScore,
+                scores: {
+                    ...scores,
+                    weights,
+                },
+            });
+        }
+        // Sort by total score descending
+        return scoredModels.sort((a, b) => b.totalScore - a.totalScore);
+    }
+    determineWeights(context) {
+        // Base weights
+        let quality = 0.25;
+        let latency = 0.20;
+        let cost = 0.20;
+        let task_fit = 0.25;
+        let reliability = 0.10;
+        // Adjust based on quality requirements
+        if (context.quality_requirements.strict) {
+            quality = 0.35;
+            task_fit = 0.30;
+            cost = 0.15;
+        }
+        // Adjust based on latency requirements
+        if (context.latency_requirements.strict) {
+            latency = 0.30;
+            quality = 0.20;
+        }
+        // Adjust based on cost optimization priority
+        if (context.budget_constraints.cost_optimization_priority === 'high') {
+            cost = 0.35;
+            quality = 0.20;
+            task_fit = 0.20;
+        }
+        // Adjust based on complexity
+        if (context.complexity === 'expert') {
+            quality = Math.min(quality + 0.10, 0.40);
+            task_fit = Math.min(task_fit + 0.05, 0.35);
+            cost = Math.max(cost - 0.10, 0.10);
+        }
+        // Normalize to sum to 1.0
+        const total = quality + latency + cost + task_fit + reliability;
+        return {
+            quality: quality / total,
+            latency: latency / total,
+            cost: cost / total,
+            task_fit: task_fit / total,
+            reliability: reliability / total,
+        };
+    }
+    calculateModelScores(model, context, history) {
+        // Quality score (based on benchmarks and history)
+        const benchmarkQuality = QUALITY_BENCHMARKS[model] || 0.7;
+        const historicalQuality = history.by_model[model]?.quality.avg_score || benchmarkQuality;
+        const quality_score = (benchmarkQuality + historicalQuality) / 2;
+        // Latency score (inverted - lower latency = higher score)
+        const benchmarkLatency = LATENCY_BENCHMARKS[model] || 2000;
+        const historicalLatency = history.by_model[model]?.latency.p95_ms || benchmarkLatency;
+        const avgLatency = (benchmarkLatency + historicalLatency) / 2;
+        const targetLatency = context.latency_requirements.target_latency_ms ||
+            context.latency_requirements.max_latency_ms;
+        const latency_score = Math.min(1.0, Math.max(0.0, 1 - (avgLatency - targetLatency * 0.5) / targetLatency));
+        // Cost score (inverted - lower cost = higher score)
+        const estimatedCost = this.estimateCostPerRequest(model, context);
+        const maxCost = context.budget_constraints.max_cost_per_request_usd || 0.5;
+        const cost_score = Math.min(1.0, Math.max(0.0, 1 - estimatedCost / maxCost));
+        // Task fit score
+        const taskSuitability = TASK_MODEL_SUITABILITY[context.task_type] ||
+            TASK_MODEL_SUITABILITY['general'];
+        const task_fit_score = taskSuitability[model] || 0.7;
+        // Reliability score (based on availability and error rate)
+        const availability = history.by_model[model]?.availability.uptime_pct || 99.5;
+        const errorRate = history.by_model[model]?.quality.error_rate || 0.02;
+        const reliability_score = (availability / 100) * (1 - errorRate);
+        return {
+            quality_score,
+            latency_score,
+            cost_score,
+            task_fit_score,
+            reliability_score,
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Recommendation Building
+    // --------------------------------------------------------------------------
+    buildRecommendations(scoredModels, input) {
+        const recommendations = [];
+        for (let i = 0; i < Math.min(scoredModels.length, this.config.maxAlternatives + 1); i++) {
+            const scored = scoredModels[i];
+            if (scored.totalScore < this.config.minConfidenceThreshold) {
+                continue;
+            }
+            const recommendation = this.buildSingleRecommendation(scored, i + 1, input.task_context, input.performance_history);
+            recommendations.push(recommendation);
+        }
+        return recommendations;
+    }
+    buildSingleRecommendation(scored, rank, context, history) {
+        const model = scored.model;
+        const provider = MODEL_PROVIDERS[model] || 'unknown';
+        // Build reasoning
+        const topScores = this.getTopScoringFactors(scored.scores);
+        const reasoning = this.buildReasoning(model, topScores, context);
+        // Build evidence
+        const evidence = this.buildEvidence(model, history, context);
+        // Build expected performance
+        const expectedPerformance = this.buildExpectedPerformance(model, context, history);
+        // Build suggested config
+        const suggestedConfig = this.buildSuggestedConfig(model, context);
+        return {
+            model_id: model,
+            provider,
+            rank,
+            suitability_score: scored.totalScore,
+            confidence: this.calculateConfidence(scored, history),
+            reasoning,
+            score_breakdown: scored.scores,
+            expected_performance: expectedPerformance,
+            evidence,
+            suggested_config: suggestedConfig,
+        };
+    }
+    getTopScoringFactors(scores) {
+        const factors = [
+            { name: 'quality', score: scores.quality_score, weight: scores.weights.quality },
+            { name: 'latency', score: scores.latency_score, weight: scores.weights.latency },
+            { name: 'cost', score: scores.cost_score, weight: scores.weights.cost },
+            { name: 'task_fit', score: scores.task_fit_score, weight: scores.weights.task_fit },
+            { name: 'reliability', score: scores.reliability_score, weight: scores.weights.reliability },
+        ];
+        return factors
+            .sort((a, b) => (b.score * b.weight) - (a.score * a.weight))
+            .slice(0, 3)
+            .map(f => f.name);
+    }
+    buildReasoning(model, topFactors, context) {
+        const parts = [];
+        parts.push(`${model} is recommended for ${context.task_type} tasks.`);
+        if (topFactors.includes('quality')) {
+            parts.push(`Strong quality performance (benchmark: ${(QUALITY_BENCHMARKS[model] || 0.8) * 100}%).`);
+        }
+        if (topFactors.includes('latency')) {
+            parts.push(`Meets latency requirements (P95: ${LATENCY_BENCHMARKS[model] || 2000}ms).`);
+        }
+        if (topFactors.includes('cost')) {
+            const costs = MODEL_COSTS[model];
+            if (costs) {
+                parts.push(`Cost-effective pricing ($${costs.input}/1K input, $${costs.output}/1K output).`);
+            }
+        }
+        if (topFactors.includes('task_fit')) {
+            parts.push(`Well-suited for ${context.task_type} based on capability analysis.`);
+        }
+        return parts.join(' ');
+    }
+    buildEvidence(model, history, context) {
+        const evidence = [];
+        // Historical performance evidence
+        const modelHistory = history.by_model[model];
+        if (modelHistory && modelHistory.request_count > 0) {
+            evidence.push({
+                type: 'historical_performance',
+                source: 'llm-observatory',
+                data: {
+                    request_count: modelHistory.request_count,
+                    avg_quality: modelHistory.quality.avg_score,
+                    p95_latency: modelHistory.latency.p95_ms,
+                    success_rate: modelHistory.quality.success_rate,
+                },
+                strength: Math.min(1.0, modelHistory.request_count / 1000),
+            });
+        }
+        // Benchmark evidence
+        evidence.push({
+            type: 'benchmark',
+            source: 'model_benchmarks',
+            data: {
+                quality_benchmark: QUALITY_BENCHMARKS[model] || 0.8,
+                latency_benchmark: LATENCY_BENCHMARKS[model] || 2000,
+                task_suitability: TASK_MODEL_SUITABILITY[context.task_type]?.[model] || 0.7,
+            },
+            strength: 0.8,
+        });
+        // Task similarity evidence
+        const taskPerf = history.by_task_type[context.task_type];
+        if (taskPerf) {
+            const modelRank = taskPerf.top_models.findIndex(m => m.model_id === model);
+            if (modelRank >= 0) {
+                evidence.push({
+                    type: 'task_similarity',
+                    source: 'task_performance_history',
+                    data: {
+                        task_type: context.task_type,
+                        rank_for_task: modelRank + 1,
+                        score_for_task: taskPerf.top_models[modelRank].score,
+                    },
+                    strength: 0.9,
+                });
+            }
+        }
+        // Cost analysis evidence
+        const costs = MODEL_COSTS[model];
+        if (costs) {
+            const estimatedCost = this.estimateCostPerRequest(model, context);
+            evidence.push({
+                type: 'cost_analysis',
+                source: 'pricing_data',
+                data: {
+                    input_cost_per_1k: costs.input,
+                    output_cost_per_1k: costs.output,
+                    estimated_cost_per_request: estimatedCost,
+                },
+                strength: 1.0,
+            });
+        }
+        return evidence;
+    }
+    buildExpectedPerformance(model, context, history) {
+        const modelHistory = history.by_model[model];
+        const benchmarkLatency = LATENCY_BENCHMARKS[model] || 2000;
+        const historicalLatency = modelHistory?.latency.p95_ms || benchmarkLatency;
+        return {
+            latency_ms: {
+                min: Math.round(historicalLatency * 0.5),
+                max: Math.round(historicalLatency * 1.2),
+                avg: Math.round(historicalLatency * 0.85),
+            },
+            quality_score: QUALITY_BENCHMARKS[model] || 0.8,
+            cost_per_request_usd: this.estimateCostPerRequest(model, context),
+            success_rate: modelHistory?.quality.success_rate || 0.98,
+            projection_confidence: modelHistory ? 0.85 : 0.7,
+        };
+    }
+    buildSuggestedConfig(model, context) {
+        const config = {};
+        // Temperature based on task type
+        if (context.task_type === 'creative_writing') {
+            config.temperature = 0.8;
+        }
+        else if (context.task_type === 'code_generation' || context.task_type === 'data_extraction') {
+            config.temperature = 0.2;
+        }
+        else {
+            config.temperature = 0.5;
+        }
+        // Max tokens based on expected output
+        config.max_tokens = Math.min(4096, context.expected_output_tokens.max);
+        // Add guidance notes
+        if (context.complexity === 'expert') {
+            config.system_prompt_notes = 'Consider using chain-of-thought prompting for complex reasoning.';
+        }
+        return config;
+    }
+    calculateConfidence(scored, history) {
+        const modelHistory = history.by_model[scored.model];
+        // Base confidence from score
+        let confidence = scored.totalScore;
+        // Boost confidence if we have historical data
+        if (modelHistory && modelHistory.request_count > 100) {
+            confidence = Math.min(1.0, confidence * 1.1);
+        }
+        // Reduce confidence if scores are close
+        // (this would require comparing to other models)
+        return Math.round(confidence * 100) / 100;
+    }
+    // --------------------------------------------------------------------------
+    // Analysis Summary Building
+    // --------------------------------------------------------------------------
+    buildAnalysisSummary(allModels, eligibleModels, scoredModels, context) {
+        const topModel = scoredModels[0]?.model || 'none';
+        const scoreMargin = scoredModels.length > 1
+            ? scoredModels[0].totalScore - scoredModels[1].totalScore
+            : 0;
+        const keyFactors = [];
+        if (context.quality_requirements.strict) {
+            keyFactors.push('Strict quality requirements applied');
+        }
+        if (context.latency_requirements.strict) {
+            keyFactors.push('Strict latency requirements applied');
+        }
+        if (context.budget_constraints.cost_optimization_priority === 'high') {
+            keyFactors.push('High cost optimization priority');
+        }
+        keyFactors.push(`Task type: ${context.task_type}`);
+        keyFactors.push(`Complexity: ${context.complexity}`);
+        const warnings = [];
+        if (eligibleModels.length < 3) {
+            warnings.push('Limited model options after constraint filtering');
+        }
+        if (scoreMargin < 0.05) {
+            warnings.push('Multiple models scored similarly - consider A/B testing');
+        }
+        if (scoredModels[0]?.totalScore < 0.7) {
+            warnings.push('Top recommendation has lower confidence - verify requirements');
+        }
+        const taskCompatibility = scoredModels[0]?.totalScore >= 0.85 ? 'excellent' :
+            scoredModels[0]?.totalScore >= 0.75 ? 'good' :
+                scoredModels[0]?.totalScore >= 0.65 ? 'adequate' : 'marginal';
+        const confidenceLevel = scoredModels[0]?.totalScore >= 0.8 ? 'high' :
+            scoredModels[0]?.totalScore >= 0.6 ? 'medium' : 'low';
+        return {
+            models_evaluated: allModels.length,
+            models_passing_constraints: eligibleModels.length,
+            top_model: topModel,
+            score_margin: Math.round(scoreMargin * 100) / 100,
+            key_factors: keyFactors,
+            warnings,
+            task_compatibility: taskCompatibility,
+            confidence_level: confidenceLevel,
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Output Building
+    // --------------------------------------------------------------------------
+    buildOutput(input, recommendations, analysisSummary, constraintEvaluations, modelsConsidered, startTime) {
+        const timestamp = new Date().toISOString();
+        const outputId = `out-${exports.AGENT_ID}-${Date.now()}`;
+        // Primary is first recommendation (or a placeholder if none)
+        const primaryRecommendation = recommendations[0] || this.buildNoRecommendationPlaceholder();
+        // Alternatives are the rest
+        const alternativeRecommendations = recommendations.slice(1);
+        const metadata = {
+            processing_duration_ms: Date.now() - startTime,
+            data_points_analyzed: Object.keys(input.performance_history.by_model).length * 5 +
+                Object.keys(input.performance_history.by_task_type).length,
+            strategies_used: ['task_fit_analysis', 'cost_analysis', 'latency_analysis', 'quality_analysis'],
+            warnings: analysisSummary.warnings,
+            models_considered: modelsConsidered,
+        };
+        return {
+            output_id: outputId,
+            execution_ref: input.execution_ref,
+            agent_version: exports.AGENT_VERSION,
+            timestamp,
+            primary_recommendation: primaryRecommendation,
+            alternative_recommendations: alternativeRecommendations,
+            analysis_summary: analysisSummary,
+            constraints_evaluated: constraintEvaluations,
+            metadata,
+        };
+    }
+    buildNoRecommendationPlaceholder() {
+        return {
+            model_id: 'none',
+            provider: 'none',
+            rank: 1,
+            suitability_score: 0,
+            confidence: 0,
+            reasoning: 'No models met all constraints. Consider relaxing constraints.',
+            score_breakdown: {
+                quality_score: 0,
+                latency_score: 0,
+                cost_score: 0,
+                task_fit_score: 0,
+                reliability_score: 0,
+                weights: {
+                    quality: 0.25,
+                    latency: 0.20,
+                    cost: 0.20,
+                    task_fit: 0.25,
+                    reliability: 0.10,
+                },
+            },
+            expected_performance: {
+                latency_ms: { min: 0, max: 0 },
+                quality_score: 0,
+                cost_per_request_usd: 0,
+                success_rate: 0,
+                projection_confidence: 0,
+            },
+            evidence: [],
+        };
+    }
+    // --------------------------------------------------------------------------
+    // DecisionEvent Building
+    // --------------------------------------------------------------------------
+    buildDecisionEvent(input, output, inputsHash, constraintEvaluations) {
+        const outputs = {
+            recommendations: [{
+                    recommendation_id: output.output_id,
+                    rank: 1,
+                    category: 'model_substitution',
+                    title: `Select ${output.primary_recommendation.model_id} for ${input.task_context.task_type}`,
+                    description: output.primary_recommendation.reasoning,
+                    proposed_changes: [{
+                            type: 'update',
+                            parameter: 'model_selection',
+                            current_value: input.current_model_config?.default_model,
+                            proposed_value: output.primary_recommendation.model_id,
+                            affected_services: input.target_services,
+                        }],
+                    expected_impact: {
+                        cost_change_pct: 0,
+                        latency_change_pct: 0,
+                        quality_change_pct: 0,
+                        confidence: output.primary_recommendation.confidence,
+                    },
+                    complexity: 'low',
+                    risk: 'low',
+                    confidence: output.primary_recommendation.confidence,
+                    evidence: output.primary_recommendation.evidence.map(e => ({
+                        type: e.type,
+                        source: e.source,
+                        data_points: e.data,
+                        strength: e.strength,
+                    })),
+                    rollout_strategy: {
+                        type: 'canary',
+                        canary_percentage: 10,
+                        rollback_criteria: {
+                            max_error_rate_increase_pct: 5,
+                            max_latency_increase_pct: 20,
+                            min_quality_threshold: 0.8,
+                            monitoring_duration_minutes: 60,
+                        },
+                    },
+                }],
+        };
+        const constraintsApplied = constraintEvaluations.map((ce, idx) => ({
+            constraint_id: `constraint-${idx}`,
+            type: ce.constraint.type,
+            value: ce.constraint.value,
+            hard: ce.constraint.hard,
+            satisfied: ce.satisfied,
+        }));
+        return {
+            agent_id: exports.AGENT_ID,
+            agent_version: exports.AGENT_VERSION,
+            decision_type: exports.DECISION_TYPE,
+            inputs_hash: inputsHash,
+            outputs,
+            confidence: output.primary_recommendation.confidence,
+            constraints_applied: constraintsApplied,
+            execution_ref: input.execution_ref,
+            timestamp: output.timestamp,
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Telemetry Emission
+    // --------------------------------------------------------------------------
+    async emitTelemetry(decisionEvent, output, durationMs) {
+        if (!this.config.telemetryEndpoint)
+            return;
+        const telemetry = {
+            agent_id: exports.AGENT_ID,
+            agent_version: exports.AGENT_VERSION,
+            execution_ref: decisionEvent.execution_ref,
+            metrics: {
+                processing_duration_ms: durationMs,
+                models_evaluated: output.metadata.models_considered.length,
+                recommendations_generated: output.alternative_recommendations.length + 1,
+                primary_confidence: output.primary_recommendation.confidence,
+                constraints_evaluated: decisionEvent.constraints_applied.length,
+                constraints_satisfied: decisionEvent.constraints_applied.filter(c => c.satisfied).length,
+            },
+            timestamp: new Date().toISOString(),
+        };
+        try {
+            await fetch(this.config.telemetryEndpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Agent-Id': exports.AGENT_ID,
+                },
+                body: JSON.stringify(telemetry),
+            });
+        }
+        catch (error) {
+            // Telemetry failure should not fail the agent
+            console.error('[ModelSelectionAgent] Telemetry emission failed:', error);
+        }
+    }
+}
+exports.ModelSelectionAgent = ModelSelectionAgent;
+// ============================================================================
+// Factory Function
+// ============================================================================
+/**
+ * Create a Model Selection Agent instance.
+ */
+function createModelSelectionAgent(config) {
+    return new ModelSelectionAgent(config);
+}
+//# sourceMappingURL=index.js.map