tachibot-mcp 2.0.2

package/dist/src/config/model-constants.js

@@ -0,0 +1,188 @@
+/**
+ * Centralized Model Names and Constants
+ * Use these constants instead of hardcoded strings in workflows and tools
+ */
+// OpenAI GPT-5 Models (August 2025)
+export const GPT5_MODELS = {
+    NANO: "gpt-5-nano", // Fastest, most cost-efficient ($0.05/$0.40 per 1M tokens)
+    MINI: "gpt-5-mini", // Balanced performance ($0.25/$2 per 1M tokens)
+    FULL: "gpt-5", // Most advanced ($1.25/$10 per 1M tokens)
+};
+// OpenAI GPT-4 Models
+export const GPT4_MODELS = {
+    O_MINI: "gpt-5-mini", // Cost-efficient
+    O: "gpt-5", // Current best
+    _1_MINI: "gpt-4.1-mini", // Best value with 1M context
+};
+// Google Gemini Models (2025)
+export const GEMINI_MODELS = {
+    FLASH: "gemini-2.5-flash", // Latest fast model
+    PRO: "gemini-2.5-pro", // Most advanced reasoning
+    FLASH_LITE: "gemini-2.5-flash-lite", // Cost-effective
+};
+// Perplexity Models
+export const PERPLEXITY_MODELS = {
+    SONAR_PRO: "sonar-pro", // Main search model
+    SONAR_REASONING: "sonar-reasoning-pro", // Reasoning model
+};
+// Grok Models (xAI) - Updated 2025-11-07
+export const GROK_MODELS = {
+    // New fast models (2025) - PRIMARY USE
+    CODE_FAST: "grok-code-fast-1", // Coding specialist: 256K→2M, $0.20/$1.50, 92 tok/sec
+    _4_FAST_REASONING: "grok-4-fast-reasoning", // Cheap reasoning: 2M→4M, $0.20/$0.50 (3x cheaper!)
+    _4_FAST: "grok-4-fast-non-reasoning", // Fast general: 2M→4M, $0.20/$0.50
+    // Expensive/specialized (use sparingly)
+    _4_HEAVY: "grok-4-0709", // Multi-agent: 256K→2M, $3/$15 (expensive!)
+    _3: "grok-3", // Legacy with search: 256K→2M
+};
+// Kimi Models (Moonshot AI via OpenRouter) - Added 2025-11-07
+export const KIMI_MODELS = {
+    K2_THINKING: "moonshotai/kimi-k2-thinking", // 1T MoE, 32B active - Leading open-source agentic reasoning (256k context)
+};
+// All models combined for validation
+export const ALL_MODELS = {
+    ...GPT5_MODELS,
+    ...GPT4_MODELS,
+    ...GEMINI_MODELS,
+    ...PERPLEXITY_MODELS,
+    ...GROK_MODELS,
+    ...KIMI_MODELS,
+};
+// Common workflow settings
+export const DEFAULT_WORKFLOW_SETTINGS = {
+    maxTokens: 2000,
+    temperature: 0.7,
+    retries: 3,
+    timeout: 30000, // 30 seconds
+};
+// Tool-specific defaults for ALL tools
+export const TOOL_DEFAULTS = {
+    // OpenAI GPT-5 tools
+    gpt5_nano: {
+        model: GPT5_MODELS.NANO,
+        maxTokens: 1000,
+        temperature: 1.0, // GPT-5 requires temperature=1
+    },
+    gpt5_mini: {
+        model: GPT5_MODELS.MINI,
+        maxTokens: 2000,
+        temperature: 1.0,
+    },
+    gpt5: {
+        model: GPT5_MODELS.FULL,
+        maxTokens: 4000,
+        temperature: 1.0,
+    },
+    // Gemini tools
+    gemini_query: {
+        model: GEMINI_MODELS.PRO,
+        maxTokens: 2048,
+        temperature: 0.7,
+    },
+    gemini_brainstorm: {
+        model: GEMINI_MODELS.PRO,
+        maxTokens: 2048,
+        temperature: 0.9,
+    },
+    gemini_analyze_code: {
+        model: GEMINI_MODELS.PRO,
+        maxTokens: 2048,
+        temperature: 0.3,
+    },
+    gemini_analyze_text: {
+        model: GEMINI_MODELS.PRO,
+        maxTokens: 2048,
+        temperature: 0.5,
+    },
+    // Perplexity tools
+    perplexity_ask: {
+        model: PERPLEXITY_MODELS.SONAR_PRO,
+        maxTokens: 2000,
+        temperature: 0.7,
+    },
+    perplexity_reason: {
+        model: PERPLEXITY_MODELS.SONAR_REASONING,
+        maxTokens: 4000,
+        temperature: 0.7,
+    },
+    perplexity_research: {
+        model: PERPLEXITY_MODELS.SONAR_PRO,
+        maxTokens: 3000,
+        temperature: 0.7,
+    },
+    // Grok tools - UPDATED with new fast models
+    grok: {
+        model: GROK_MODELS._4_FAST_REASONING, // Changed: 3x cheaper output
+        maxTokens: 4000,
+        temperature: 0.7,
+    },
+    grok_reason: {
+        model: GROK_MODELS._4_FAST_REASONING, // Changed: 3x cheaper, 8x context
+        maxTokens: 8000,
+        temperature: 0.7,
+    },
+    grok_code: {
+        model: GROK_MODELS.CODE_FAST, // Changed: Coding specialist, 3x faster
+        maxTokens: 4000,
+        temperature: 0.3,
+    },
+    grok_search: {
+        model: GROK_MODELS._4_FAST_REASONING, // Changed: Use fast reasoning with search
+        maxTokens: 3000,
+        temperature: 0.7,
+    },
+    grok_brainstorm: {
+        model: GROK_MODELS._4_FAST, // Changed: Fast non-reasoning for creativity
+        maxTokens: 4000,
+        temperature: 0.9,
+    },
+    grok_architect: {
+        model: GROK_MODELS._4_FAST_REASONING, // New: Architecture needs reasoning
+        maxTokens: 4000,
+        temperature: 0.6,
+    },
+    grok_debug: {
+        model: GROK_MODELS.CODE_FAST, // New: Use code specialist for debugging
+        maxTokens: 3000,
+        temperature: 0.3,
+    },
+    // Qwen tools (via OpenRouter)
+    qwen_coder: {
+        maxTokens: 4000,
+        temperature: 0.5,
+    },
+    // Kimi tools (via OpenRouter)
+    kimi_thinking: {
+        model: KIMI_MODELS.K2_THINKING,
+        maxTokens: 16000, // Large for detailed reasoning chains
+        temperature: 0.7, // Higher for creative reasoning
+    },
+    // Meta tools (think, focus, code_reviewer, etc.)
+    think: {
+        model: GPT5_MODELS.MINI,
+        maxTokens: 500,
+        temperature: 0.7,
+    },
+    focus: {
+        model: GPT5_MODELS.MINI,
+        maxTokens: 2000,
+        temperature: 0.8,
+    },
+    code_reviewer: {
+        model: GPT5_MODELS.MINI,
+        maxTokens: 2000,
+        temperature: 0.5,
+    },
+    test_architect: {
+        model: GPT5_MODELS.MINI,
+        maxTokens: 2000,
+        temperature: 0.6,
+    },
+    documentation_writer: {
+        model: GPT5_MODELS.MINI,
+        maxTokens: 2000,
+        temperature: 0.7,
+    },
+};
+// Default tool to use in workflows if not specified
+export const DEFAULT_WORKFLOW_TOOL = "gpt5_mini";

package/dist/src/config/model-defaults.js

@@ -0,0 +1,57 @@
+/**
+ * Model Selection Configuration
+ *
+ * Provides configurable model selection for Scout, Challenger, and Verifier tools
+ * with smart defaults that balance cost and quality.
+ *
+ * Environment variables allow users to override defaults via Claude Desktop config.
+ */
+/**
+ * Get Scout model configuration
+ *
+ * Defaults:
+ * - quick_scout: Flash + gpt-5-mini (speed + cost efficient)
+ * - research_scout: Pro + gpt-5-mini (quality + cost balance)
+ */
+export function getScoutModels() {
+    const quick = process.env.SCOUT_QUICK_MODELS?.split(',').map(m => m.trim()) ||
+        ['qwen/qwen3-coder-plus', 'gemini-2.5-flash', 'gpt-5-mini'];
+    const research = process.env.SCOUT_RESEARCH_MODELS?.split(',').map(m => m.trim()) ||
+        ['qwen/qwen3-coder-plus', 'gemini-2.5-pro', 'gpt-5-mini'];
+    return { quick, research };
+}
+/**
+ * Get Challenger model configuration
+ *
+ * Defaults: Pro + gpt-5-mini (quality for critical analysis, cost efficient)
+ */
+export function getChallengerModels() {
+    return process.env.CHALLENGER_MODELS?.split(',').map(m => m.trim()) ||
+        ['qwen/qwen3-coder-plus', 'gemini-2.5-pro', 'gpt-5-mini'];
+}
+/**
+ * Get Verifier model configuration
+ *
+ * Defaults:
+ * - quick_verify: Flash + gpt-5-mini (fast checks, cost efficient)
+ * - standard modes: Pro + gpt-5-mini (quality + cost balance)
+ * - deep_verify: Pro + gpt-5 (maximum quality for critical verification)
+ */
+export function getVerifierModels() {
+    const quick = process.env.VERIFIER_QUICK_MODELS?.split(',').map(m => m.trim()) ||
+        ['qwen/qwen3-coder-plus', 'gemini-2.5-flash', 'gpt-5-mini'];
+    const deep = process.env.VERIFIER_DEEP_MODELS?.split(',').map(m => m.trim()) ||
+        ['qwen/qwen3-coder-plus', 'gemini-2.5-pro', 'gpt-5'];
+    const standard = process.env.VERIFIER_STANDARD_MODELS?.split(',').map(m => m.trim()) ||
+        ['qwen/qwen3-coder-plus', 'gemini-2.5-pro', 'gpt-5-mini'];
+    return { quick, deep, standard };
+}
+/**
+ * Get default fallback models (used when variant has no specific config)
+ *
+ * Default: Pro + gpt-5-mini (balanced quality and cost)
+ */
+export function getDefaultModels() {
+    return process.env.DEFAULT_MODELS?.split(',').map(m => m.trim()) ||
+        ['qwen/qwen3-coder-plus', 'gemini-2.5-pro', 'gpt-5-mini'];
+}

package/dist/src/config/model-preferences.js

@@ -0,0 +1,382 @@
+/**
+ * Model Preferences Configuration
+ * Allows users to set their preferred models based on available API tokens
+ */
+/**
+ * Default model configurations with user preferences
+ */
+export class ModelPreferencesManager {
+    constructor() {
+        this.preferences = {};
+        this.availableModels = new Map();
+        this.loadPreferences();
+        this.initializeModels();
+    }
+    /**
+     * Load preferences from environment variables
+     */
+    loadPreferences() {
+        // Check for user preferences in environment
+        const primaryModel = process.env.PRIMARY_REASONING_MODEL;
+        const backupModels = process.env.BACKUP_REASONING_MODELS?.split(",").map((m) => m.trim());
+        const enableExpensive = process.env.ENABLE_EXPENSIVE_MODELS === "true";
+        const preferGrok = process.env.PREFER_GROK === "true";
+        const preferO3 = process.env.PREFER_O3 === "true";
+        const defaultBackups = ["gpt5_mini", "gpt41_mini", "gpt5"];
+        this.preferences = {
+            primaryReasoning: primaryModel || "gpt5",
+            backupReasoning: backupModels && backupModels.length > 0 ? backupModels : defaultBackups,
+            primaryResearch: process.env.PRIMARY_RESEARCH_MODEL,
+            primaryAnalysis: process.env.PRIMARY_ANALYSIS_MODEL,
+            enableExpensiveModels: enableExpensive,
+            modelOverrides: {},
+        };
+        // Handle specific model preferences
+        if (preferGrok) {
+            this.preferences.primaryReasoning = "grok_heavy";
+            this.preferences.enableExpensiveModels = true;
+        }
+        if (preferO3) {
+            this.preferences.primaryReasoning = "openai_gpt5_reason";
+            this.preferences.enableExpensiveModels = true;
+        }
+        // Load model-specific overrides from environment
+        this.loadModelOverrides();
+    }
+    /**
+     * Load model-specific overrides
+     */
+    loadModelOverrides() {
+        // GPT-5 configuration (assumes OpenAI key)
+        if (process.env.OPENAI_API_KEY) {
+            this.preferences.modelOverrides["gpt5"] = {
+                enabled: process.env.DISABLE_GPT5 !== "true",
+                priority: parseInt(process.env.GPT5_PRIORITY || "0"),
+                maxTokens: parseInt(process.env.GPT5_MAX_TOKENS || "8000"),
+                costLimit: parseFloat(process.env.GPT5_COST_LIMIT || "5.0"),
+            };
+            this.preferences.modelOverrides["gpt5_mini"] = {
+                enabled: process.env.DISABLE_GPT5_MINI === "true" ? false : true,
+                priority: parseInt(process.env.GPT5_MINI_PRIORITY || "1"),
+                maxTokens: parseInt(process.env.GPT5_MINI_MAX_TOKENS || "6000"),
+                costLimit: parseFloat(process.env.GPT5_MINI_COST_LIMIT || "2.5"),
+            };
+        }
+        // Grok configuration
+        if (process.env.GROK_API_KEY) {
+            this.preferences.modelOverrides["grok_reason"] = {
+                enabled: true,
+                priority: parseInt(process.env.GROK_PRIORITY || "2"),
+                maxTokens: parseInt(process.env.GROK_MAX_TOKENS || "100000"),
+                costLimit: parseFloat(process.env.GROK_COST_LIMIT || "1.0"),
+            };
+            this.preferences.modelOverrides["grok_heavy"] = {
+                enabled: process.env.ENABLE_GROK_HEAVY === "true",
+                priority: parseInt(process.env.GROK_HEAVY_PRIORITY || "1"),
+                maxTokens: parseInt(process.env.GROK_HEAVY_MAX_TOKENS || "256000"),
+                costLimit: parseFloat(process.env.GROK_HEAVY_COST_LIMIT || "5.0"),
+            };
+        }
+        // GPT-5 reasoning configuration
+        if (process.env.OPENAI_API_KEY) {
+            this.preferences.modelOverrides["gpt5_reason"] = {
+                enabled: process.env.ENABLE_GPT5 === "true",
+                priority: parseInt(process.env.GPT5_REASON_PRIORITY || "1"),
+                maxTokens: parseInt(process.env.GPT5_REASON_MAX_TOKENS || "100000"),
+                costLimit: parseFloat(process.env.GPT5_REASON_COST_LIMIT || "2.0"),
+            };
+            this.preferences.modelOverrides["gpt5_mini_reason"] = {
+                enabled: true, // Always enabled, no confirmation needed
+                priority: parseInt(process.env.GPT5_MINI_REASON_PRIORITY || "2"),
+                maxTokens: parseInt(process.env.GPT5_MINI_REASON_MAX_TOKENS || "128000"),
+                costLimit: parseFloat(process.env.GPT5_MINI_REASON_COST_LIMIT || "1.5"),
+            };
+        }
+        // DeepSeek R1
+        if (process.env.DEEPSEEK_API_KEY) {
+            this.preferences.modelOverrides["deepseek_r1"] = {
+                enabled: process.env.ENABLE_DEEPSEEK_R1 === "true",
+                priority: parseInt(process.env.DEEPSEEK_R1_PRIORITY || "3"),
+                maxTokens: parseInt(process.env.DEEPSEEK_R1_MAX_TOKENS || "64000"),
+                costLimit: parseFloat(process.env.DEEPSEEK_R1_COST_LIMIT || "0.5"),
+            };
+        }
+        // Qwen models via OpenRouter
+        if (process.env.OPENROUTER_API_KEY) {
+            this.preferences.modelOverrides["qwen_coder"] = {
+                enabled: true,
+                priority: parseInt(process.env.QWEN_CODER_PRIORITY || "4"),
+                maxTokens: parseInt(process.env.QWEN_CODER_MAX_TOKENS || "32000"),
+                costLimit: parseFloat(process.env.QWEN_CODER_COST_LIMIT || "0.3"),
+            };
+            this.preferences.modelOverrides["qwq_reason"] = {
+                enabled: true,
+                priority: parseInt(process.env.QWQ_PRIORITY || "3"),
+                maxTokens: parseInt(process.env.QWQ_MAX_TOKENS || "32000"),
+                costLimit: parseFloat(process.env.QWQ_COST_LIMIT || "0.2"),
+            };
+        }
+    }
+    /**
+     * Initialize available models based on API keys
+     */
+    initializeModels() {
+        // Check which APIs are available
+        const hasGrok = !!process.env.GROK_API_KEY;
+        const hasOpenAI = !!process.env.OPENAI_API_KEY;
+        const hasGemini = !!process.env.GOOGLE_API_KEY;
+        const hasPerplexity = !!process.env.PERPLEXITY_API_KEY;
+        const hasOpenRouter = !!process.env.OPENROUTER_API_KEY;
+        const hasDeepSeek = !!process.env.DEEPSEEK_API_KEY;
+        // Set up available models with default configs
+        if (hasGrok) {
+            this.availableModels.set("grok_reason", {
+                enabled: true,
+                priority: 5,
+            });
+            this.availableModels.set("grok_heavy", {
+                enabled: this.preferences.enableExpensiveModels || false,
+                priority: 2,
+            });
+            this.availableModels.set("grok_code", {
+                enabled: true,
+                priority: 4,
+            });
+        }
+        if (hasOpenAI) {
+            const gpt5Override = this.preferences.modelOverrides?.["gpt5"];
+            this.availableModels.set("gpt5", {
+                enabled: gpt5Override?.enabled !== false,
+                priority: gpt5Override?.priority ?? 0,
+                maxTokens: gpt5Override?.maxTokens,
+                costLimit: gpt5Override?.costLimit,
+            });
+            const gpt5MiniOverride = this.preferences.modelOverrides?.["gpt5_mini"];
+            this.availableModels.set("gpt5_mini", {
+                enabled: gpt5MiniOverride?.enabled !== false,
+                priority: gpt5MiniOverride?.priority ?? 1,
+                maxTokens: gpt5MiniOverride?.maxTokens,
+                costLimit: gpt5MiniOverride?.costLimit,
+            });
+            const gpt41Override = this.preferences.modelOverrides?.["gpt41_mini"];
+            this.availableModels.set("gpt41_mini", {
+                enabled: true,
+                priority: Math.max(gpt41Override?.priority ?? 4, 4),
+                maxTokens: gpt41Override?.maxTokens,
+                costLimit: gpt41Override?.costLimit,
+            });
+            // Removed deprecated gpt4o - use gpt5_mini instead
+            this.availableModels.set("gpt5_reason", {
+                enabled: this.preferences.enableExpensiveModels || false,
+                priority: 2,
+            });
+            this.availableModels.set("gpt5_mini_reason", {
+                enabled: true, // Always available
+                priority: 3,
+            });
+        }
+        if (hasGemini) {
+            this.availableModels.set("gemini_25_pro", {
+                enabled: true,
+                priority: 6,
+            });
+            this.availableModels.set("gemini_brainstorm", {
+                enabled: true,
+                priority: 7,
+            });
+        }
+        if (hasDeepSeek) {
+            this.availableModels.set("deepseek_r1", {
+                enabled: this.preferences.enableExpensiveModels || false,
+                priority: 3,
+            });
+        }
+        if (hasOpenRouter) {
+            this.availableModels.set("qwen_coder", {
+                enabled: true,
+                priority: 5,
+            });
+            this.availableModels.set("qwq_reason", {
+                enabled: true,
+                priority: 4,
+            });
+        }
+        // Apply user overrides
+        for (const [model, config] of Object.entries(this.preferences.modelOverrides || {})) {
+            if (this.availableModels.has(model)) {
+                this.availableModels.set(model, {
+                    ...this.availableModels.get(model),
+                    ...config,
+                });
+            }
+        }
+        // Ensure primary reasoning defaults to GPT-5 when available
+        if (!this.preferences.primaryReasoning &&
+            this.availableModels.get("gpt5")?.enabled) {
+            this.preferences.primaryReasoning = "gpt5";
+        }
+    }
+    /**
+     * Get the best model for a specific task
+     */
+    getBestModelForTask(taskType, allowExpensive = false) {
+        // Check for explicit preferences first
+        if (taskType === "reasoning" && this.preferences.primaryReasoning) {
+            const model = this.availableModels.get(this.preferences.primaryReasoning);
+            if (model?.enabled) {
+                return this.preferences.primaryReasoning;
+            }
+        }
+        if (taskType === "research" && this.preferences.primaryResearch) {
+            const model = this.availableModels.get(this.preferences.primaryResearch);
+            if (model?.enabled) {
+                return this.preferences.primaryResearch;
+            }
+        }
+        // Find best available model by priority
+        const candidates = [];
+        for (const [modelId, config] of this.availableModels.entries()) {
+            if (!config.enabled)
+                continue;
+            // Skip expensive models unless allowed
+            if (!allowExpensive && !this.preferences.enableExpensiveModels) {
+                const expensiveModels = [
+                    "grok_heavy",
+                    "gpt5_reason",
+                    "deepseek_r1",
+                ];
+                if (expensiveModels.includes(modelId))
+                    continue;
+            }
+            // Filter by task type
+            if (taskType === "reasoning") {
+                if (modelId.includes("reason") ||
+                    modelId.includes("think") ||
+                    modelId.includes("gpt5") ||
+                    modelId === "grok_heavy" ||
+                    modelId === "deepseek_r1") {
+                    candidates.push([modelId, config]);
+                }
+            }
+            else if (taskType === "code") {
+                if (modelId.includes("code") || modelId.includes("coder")) {
+                    candidates.push([modelId, config]);
+                }
+            }
+            else if (taskType === "research") {
+                if (modelId.includes("perplexity") ||
+                    modelId.includes("scout") ||
+                    modelId.includes("research")) {
+                    candidates.push([modelId, config]);
+                }
+            }
+            else if (taskType === "analysis") {
+                if (modelId.includes("analyze") ||
+                    modelId.includes("gpt5") ||
+                    modelId.includes("gemini")) {
+                    candidates.push([modelId, config]);
+                }
+            }
+        }
+        // Sort by priority (lower number = higher priority)
+        candidates.sort((a, b) => a[1].priority - b[1].priority);
+        return candidates.length > 0 ? candidates[0][0] : null;
+    }
+    /**
+     * Get fallback chain for a model
+     */
+    getFallbackChain(primaryModel) {
+        const chain = [];
+        // Add user-specified backups first
+        if (this.preferences.backupReasoning) {
+            for (const backup of this.preferences.backupReasoning) {
+                const model = this.availableModels.get(backup);
+                if (model?.enabled && backup !== primaryModel) {
+                    chain.push(backup);
+                }
+            }
+        }
+        // Ensure GPT-5 family fallback ordering is respected
+        const preferredFallbacks = ["gpt5_mini", "gpt41_mini", "gpt5"];
+        for (const candidate of preferredFallbacks) {
+            if (candidate !== primaryModel) {
+                const config = this.availableModels.get(candidate);
+                if (config?.enabled && !chain.includes(candidate)) {
+                    chain.push(candidate);
+                }
+            }
+        }
+        // Add automatic fallbacks based on availability and priority
+        const sortedModels = Array.from(this.availableModels.entries())
+            .filter(([id, config]) => config.enabled && id !== primaryModel)
+            .sort((a, b) => a[1].priority - b[1].priority)
+            .map(([id]) => id);
+        // Add top 3 alternatives not already in chain
+        for (const model of sortedModels) {
+            if (!chain.includes(model)) {
+                chain.push(model);
+                if (chain.length >= 3)
+                    break;
+            }
+        }
+        return chain;
+    }
+    /**
+     * Check if a model is available and enabled
+     */
+    isModelAvailable(modelId) {
+        const model = this.availableModels.get(modelId);
+        return model?.enabled || false;
+    }
+    /**
+     * Get model configuration
+     */
+    getModelConfig(modelId) {
+        return this.availableModels.get(modelId) || null;
+    }
+    /**
+     * Update model preference at runtime
+     */
+    setModelPreference(modelId, config) {
+        const existing = this.availableModels.get(modelId);
+        if (existing) {
+            this.availableModels.set(modelId, { ...existing, ...config });
+        }
+    }
+    /**
+     * Get recommendations based on user's available APIs
+     */
+    getRecommendations() {
+        const recommendations = [];
+        const hasGrok = !!process.env.GROK_API_KEY;
+        const hasOpenAI = !!process.env.OPENAI_API_KEY;
+        if (hasGrok && !this.preferences.enableExpensiveModels) {
+            recommendations.push("You have Grok API access. Enable ENABLE_EXPENSIVE_MODELS=true to use Grok Heavy (256k context).");
+        }
+        if (hasOpenAI && !this.isModelAvailable("gpt5_reason")) {
+            recommendations.push("You have OpenAI API access. Enable ENABLE_GPT5=true to use GPT-5 reasoning models.");
+        }
+        if (!this.preferences.primaryReasoning) {
+            const bestModel = this.getBestModelForTask("reasoning", true);
+            if (bestModel) {
+                recommendations.push(`Set PRIMARY_REASONING_MODEL=${bestModel} in .env for optimal performance.`);
+            }
+        }
+        return recommendations;
+    }
+    /**
+     * Export current configuration for debugging
+     */
+    exportConfiguration() {
+        return {
+            preferences: this.preferences,
+            availableModels: Array.from(this.availableModels.entries()).map(([id, config]) => ({
+                id,
+                config,
+            })),
+            recommendations: this.getRecommendations(),
+        };
+    }
+}
+// Export singleton instance
+export const modelPreferences = new ModelPreferencesManager();