tachibot-mcp 2.0.2

package/dist/src/optimization/model-router.js

@@ -0,0 +1,264 @@
+/**
+ * Smart Model Router - Optimized model selection based on query complexity
+ * Part of Phase 1A implementation for cost optimization
+ */
+export var ModelTier;
+(function (ModelTier) {
+    // Tier 0: NEW! GPT-5 Nano - CHEAPEST OPTION
+    ModelTier["ULTRA_CHEAP"] = "gpt-5-nano";
+    // Tier 1: Ultra Fast & Cheap (< $0.001 per request)
+    ModelTier["ULTRA_EFFICIENT"] = "gemini-2.5-flash";
+    ModelTier["EFFICIENT"] = "gpt-5-mini";
+    // Tier 2: Balanced ($0.001-$0.01 per request)
+    ModelTier["STANDARD"] = "gpt-5";
+    ModelTier["GPT5_MINI"] = "gpt-5-mini";
+    // Tier 3: Advanced ($0.01-$0.05 per request)
+    ModelTier["WEB_SEARCH"] = "perplexity-sonar-pro";
+    // Tier 4: Premium (Use with caution)
+    ModelTier["GPT5_FULL"] = "gpt-5";
+})(ModelTier || (ModelTier = {}));
+const MODEL_COSTS = {
+    // GPT-5 Models (Nov 2025 pricing)
+    "gpt-5-nano": { input: 0.00005, output: 0.0004, latency: 400 }, // CHEAPEST!
+    "gpt-5-mini": { input: 0.00025, output: 0.002, latency: 800 },
+    "gpt-5": { input: 0.00125, output: 0.01, latency: 2000 },
+    // Existing models
+    "gemini-2.5-flash": { input: 0.000075, output: 0.0003, latency: 500 },
+    "gemini-2.5-pro": { input: 0.00015, output: 0.0006, latency: 1000 },
+    qwencoder: { input: 0.00015, output: 0.0006, latency: 1000 },
+    "perplexity-sonar-pro": { input: 0.006, output: 0.006, latency: 2000 },
+};
+export class SmartModelRouter {
+    constructor() {
+        this.complexityCache = new Map();
+    }
+    /**
+     * Analyze query to determine complexity
+     */
+    analyzeComplexity(query) {
+        // Check cache first
+        const cached = this.complexityCache.get(query);
+        if (cached)
+            return cached;
+        const wordCount = query.split(/\s+/).length;
+        const hasCode = /```|function|class|import|const|let|var/.test(query);
+        const hasMultiStep = /step|first|then|after|finally|additionally/.test(query.toLowerCase());
+        const hasMath = /calculate|solve|equation|formula/.test(query.toLowerCase());
+        const hasAnalysis = /analyze|compare|evaluate|assess/.test(query.toLowerCase());
+        let complexity = "simple";
+        if (wordCount > 100 || hasMultiStep || hasMath) {
+            complexity = "complex";
+        }
+        else if (wordCount > 30 || hasCode || hasAnalysis) {
+            complexity = "moderate";
+        }
+        // Cache for reuse
+        this.complexityCache.set(query, complexity);
+        return complexity;
+    }
+    /**
+     * Detect query type from content
+     */
+    detectQueryType(query) {
+        const lowerQuery = query.toLowerCase();
+        if (/```|function|class|implement|debug|fix/.test(query)) {
+            return "code";
+        }
+        if (/research|find|search|what is|explain/.test(lowerQuery)) {
+            return "research";
+        }
+        if (/analyze|compare|evaluate|assess/.test(lowerQuery)) {
+            return "analysis";
+        }
+        if (/think|reason|solve|calculate|prove/.test(lowerQuery)) {
+            return "reasoning";
+        }
+        return "chat";
+    }
+    /**
+     * Build context from query
+     */
+    buildContext(query, overrides) {
+        return {
+            query,
+            complexity: this.analyzeComplexity(query),
+            type: this.detectQueryType(query),
+            requiresWeb: /current|latest|today|news|http|www/.test(query),
+            requiresReasoning: /why|how|solve|prove|calculate/.test(query.toLowerCase()),
+            urgency: "normal",
+            costSensitive: true, // Default to cost-sensitive
+            ...overrides,
+        };
+    }
+    /**
+     * Select optimal model based on context
+     */
+    selectModel(context) {
+        // Rule 1: Simple queries → GPT-5 Nano (CHEAPEST!)
+        if (context.complexity === "simple" && context.costSensitive !== false) {
+            // Check if GPT-5 is enabled
+            const gpt5Enabled = process.env.ENABLE_GPT5 !== "false";
+            if (gpt5Enabled) {
+                return {
+                    primary: ModelTier.ULTRA_CHEAP, // gpt-5-nano
+                    fallback: ModelTier.ULTRA_EFFICIENT, // gemini-2.5-flash
+                    estimatedCost: 0.000008, // Even cheaper than gemini!
+                    estimatedLatency: 400,
+                    requiresConfirmation: false,
+                    reasoning: "Simple query - using GPT-5 Nano (cheapest option)",
+                };
+            }
+            else {
+                return {
+                    primary: ModelTier.ULTRA_EFFICIENT, // gemini-2.5-flash
+                    fallback: ModelTier.EFFICIENT,
+                    estimatedCost: 0.00001,
+                    estimatedLatency: 500,
+                    requiresConfirmation: false,
+                    reasoning: "Simple query - using Gemini Flash (GPT-5 disabled)",
+                };
+            }
+        }
+        // Rule 2: Web search required → Perplexity
+        if (context.requiresWeb) {
+            return {
+                primary: ModelTier.WEB_SEARCH,
+                fallback: ModelTier.STANDARD,
+                estimatedCost: 0.006,
+                estimatedLatency: 2000,
+                requiresConfirmation: false,
+                reasoning: "Web search required - using Perplexity",
+            };
+        }
+        // Rule 3: Code generation → GPT-5 (proven best)
+        if (context.type === "code") {
+            if (context.complexity === "complex") {
+                return {
+                    primary: ModelTier.STANDARD,
+                    fallback: ModelTier.EFFICIENT,
+                    estimatedCost: 0.005,
+                    estimatedLatency: 1500,
+                    requiresConfirmation: false,
+                    reasoning: "Complex code generation - using GPT-5",
+                };
+            }
+            return {
+                primary: ModelTier.EFFICIENT,
+                fallback: ModelTier.ULTRA_EFFICIENT,
+                estimatedCost: 0.0003,
+                estimatedLatency: 1000,
+                requiresConfirmation: false,
+                reasoning: "Simple code task - using GPT-5-mini",
+            };
+        }
+        // Rule 4: Complex reasoning → GPT-5 models
+        if (context.requiresReasoning && context.complexity !== "simple") {
+            if (context.urgency === "fast" || context.costSensitive) {
+                return {
+                    primary: ModelTier.EFFICIENT,
+                    fallback: ModelTier.STANDARD,
+                    estimatedCost: 0.003,
+                    estimatedLatency: 2000,
+                    requiresConfirmation: false,
+                    reasoning: "Reasoning required - using gpt-5-mini for speed/cost",
+                };
+            }
+            if (context.complexity === "complex") {
+                return {
+                    primary: ModelTier.STANDARD,
+                    fallback: ModelTier.EFFICIENT,
+                    estimatedCost: 0.015,
+                    estimatedLatency: 3000,
+                    requiresConfirmation: true, // Expensive
+                    reasoning: "Complex reasoning - using gpt-5 (requires confirmation)",
+                };
+            }
+        }
+        // Rule 5: Moderate complexity → Balanced
+        if (context.complexity === "moderate") {
+            return {
+                primary: ModelTier.EFFICIENT,
+                fallback: ModelTier.ULTRA_EFFICIENT,
+                estimatedCost: 0.0003,
+                estimatedLatency: 1000,
+                requiresConfirmation: false,
+                reasoning: "Moderate complexity - using GPT-5-mini",
+            };
+        }
+        // Default: Cost-efficient
+        return {
+            primary: ModelTier.EFFICIENT,
+            fallback: ModelTier.ULTRA_EFFICIENT,
+            estimatedCost: 0.00015,
+            estimatedLatency: 1000,
+            requiresConfirmation: false,
+            reasoning: "Default selection - using cost-efficient model",
+        };
+    }
+    /**
+     * Estimate cost for a request
+     */
+    estimateCost(model, estimatedTokens) {
+        const costs = MODEL_COSTS[model];
+        if (!costs)
+            return 0.001; // Default estimate
+        // Assume 40% input, 60% output for typical usage
+        const inputTokens = estimatedTokens * 0.4;
+        const outputTokens = estimatedTokens * 0.6;
+        return (inputTokens * costs.input + outputTokens * costs.output) / 1000;
+    }
+    /**
+     * Get model recommendations for a query
+     */
+    getRecommendations(query) {
+        const context = this.buildContext(query);
+        const optimal = this.selectModel(context);
+        // Generate alternatives
+        const alternatives = [];
+        // Cheaper alternative
+        const cheaperContext = {
+            ...context,
+            costSensitive: true,
+            complexity: "simple",
+        };
+        const cheaper = this.selectModel(cheaperContext);
+        if (cheaper.primary !== optimal.primary) {
+            alternatives.push({ ...cheaper, reasoning: "Cheaper alternative" });
+        }
+        // Faster alternative
+        const fasterContext = { ...context, urgency: "fast" };
+        const faster = this.selectModel(fasterContext);
+        if (faster.primary !== optimal.primary &&
+            faster.primary !== cheaper.primary) {
+            alternatives.push({ ...faster, reasoning: "Faster alternative" });
+        }
+        // Higher quality alternative
+        const qualityContext = {
+            ...context,
+            costSensitive: false,
+            complexity: "complex",
+        };
+        const quality = this.selectModel(qualityContext);
+        if (quality.primary !== optimal.primary) {
+            alternatives.push({
+                ...quality,
+                reasoning: "Higher quality alternative",
+            });
+        }
+        return {
+            optimal,
+            alternatives: alternatives.slice(0, 3), // Max 3 alternatives
+            context,
+        };
+    }
+    /**
+     * Clear complexity cache (call periodically to prevent memory growth)
+     */
+    clearCache() {
+        if (this.complexityCache.size > 1000) {
+            this.complexityCache.clear();
+        }
+    }
+}
+// Export singleton instance
+export const modelRouter = new SmartModelRouter();

package/dist/src/optimization/result-cache.js

@@ -0,0 +1,114 @@
+import * as crypto from 'crypto';
+export class ResultCache {
+    constructor(maxSize, ttl) {
+        this.cache = new Map();
+        this.maxSize = 1000;
+        this.ttl = 3600000; // 1 hour default
+        this.stats = {
+            hits: 0,
+            misses: 0,
+            evictions: 0
+        };
+        if (maxSize)
+            this.maxSize = maxSize;
+        if (ttl)
+            this.ttl = ttl;
+        // Periodic cleanup
+        setInterval(() => this.cleanup(), 60000); // Every minute
+    }
+    async get(key) {
+        const hash = this.hashKey(key);
+        const entry = this.cache.get(hash);
+        if (!entry) {
+            this.stats.misses++;
+            return null;
+        }
+        const age = Date.now() - entry.timestamp;
+        if (age > this.ttl) {
+            this.cache.delete(hash);
+            this.stats.misses++;
+            return null;
+        }
+        entry.hits++;
+        entry.lastAccessed = Date.now();
+        this.stats.hits++;
+        return entry.result;
+    }
+    async set(key, value) {
+        const hash = this.hashKey(key);
+        if (this.cache.size >= this.maxSize) {
+            this.evictLRU();
+        }
+        this.cache.set(hash, {
+            key: hash,
+            result: value.result,
+            tokens: value.tokens || 0,
+            timestamp: value.timestamp || Date.now(),
+            hits: 0,
+            lastAccessed: Date.now()
+        });
+    }
+    getStats() {
+        const totalHits = this.stats.hits;
+        const totalMisses = this.stats.misses;
+        const hitRate = totalHits / (totalHits + totalMisses) || 0;
+        let tokensSaved = 0;
+        let memorySaved = 0;
+        for (const entry of this.cache.values()) {
+            if (entry.hits > 0) {
+                tokensSaved += entry.tokens * entry.hits;
+                memorySaved += JSON.stringify(entry.result).length * entry.hits;
+            }
+        }
+        return {
+            totalEntries: this.cache.size,
+            totalHits,
+            totalMisses,
+            hitRate,
+            memorySaved,
+            tokensSaved
+        };
+    }
+    clear() {
+        this.cache.clear();
+        this.stats = { hits: 0, misses: 0, evictions: 0 };
+    }
+    hashKey(key) {
+        return crypto.createHash('sha256').update(key).digest('hex').substring(0, 16);
+    }
+    evictLRU() {
+        let oldest = null;
+        let oldestKey = null;
+        for (const [key, entry] of this.cache) {
+            if (!oldest || entry.lastAccessed < oldest.lastAccessed) {
+                oldest = entry;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey) {
+            this.cache.delete(oldestKey);
+            this.stats.evictions++;
+        }
+    }
+    cleanup() {
+        const now = Date.now();
+        const keysToDelete = [];
+        for (const [key, entry] of this.cache) {
+            if (now - entry.timestamp > this.ttl) {
+                keysToDelete.push(key);
+            }
+        }
+        for (const key of keysToDelete) {
+            this.cache.delete(key);
+        }
+    }
+    setTTL(ttl) {
+        this.ttl = ttl;
+    }
+    setMaxSize(size) {
+        this.maxSize = size;
+        while (this.cache.size > this.maxSize) {
+            this.evictLRU();
+        }
+    }
+}

package/dist/src/optimization/token-optimizer.js

@@ -0,0 +1,257 @@
+/**
+ * Token Optimizer - Caching, compression, and batching for token efficiency
+ * Part of Phase 1B implementation for 70% cost reduction
+ */
+import { LRUCache } from 'lru-cache';
+import crypto from 'crypto';
+export class TokenOptimizer {
+    constructor() {
+        // Batch queue for request batching
+        this.batchQueue = [];
+        this.batchTimer = null;
+        // Configuration
+        this.config = {
+            cacheMaxSize: 100 * 1024 * 1024, // 100MB
+            cacheTTL: 60 * 60 * 1000, // 1 hour
+            batchWindow: 100, // ms to wait for batch
+            maxBatchSize: 10, // max requests per batch
+            compressionThreshold: 2000, // characters
+            compressionModel: 'gemini-2.5-flash', // Ultra cheap for compression
+        };
+        // Metrics
+        this.metrics = {
+            cacheHits: 0,
+            cacheMisses: 0,
+            tokensCompressed: 0,
+            tokensSaved: 0,
+            batchesProcessed: 0,
+        };
+        this.responseCache = new LRUCache({
+            max: 1000, // Max 1000 entries
+            ttl: this.config.cacheTTL,
+            updateAgeOnGet: true,
+            updateAgeOnHas: true,
+        });
+    }
+    /**
+     * Generate cache key for a request
+     */
+    generateCacheKey(request) {
+        if (request.cacheKey)
+            return request.cacheKey;
+        const keyData = {
+            prompt: request.prompt,
+            model: request.model,
+            temperature: request.temperature || 0.7,
+        };
+        return crypto
+            .createHash('sha256')
+            .update(JSON.stringify(keyData))
+            .digest('hex');
+    }
+    /**
+     * Check cache for existing response
+     */
+    checkCache(request) {
+        const key = this.generateCacheKey(request);
+        const cached = this.responseCache.get(key);
+        if (cached) {
+            this.metrics.cacheHits++;
+            cached.hits++;
+            return cached;
+        }
+        this.metrics.cacheMisses++;
+        return null;
+    }
+    /**
+     * Compress prompt using cheap model (simulated for now)
+     */
+    async compressPrompt(prompt) {
+        // In production, this would call the actual compression model
+        // For now, we'll simulate compression by removing redundancy
+        if (prompt.length < this.config.compressionThreshold) {
+            return prompt;
+        }
+        // Simulated compression techniques:
+        // 1. Remove excessive whitespace
+        let compressed = prompt.replace(/\s+/g, ' ').trim();
+        // 2. Remove duplicate sentences
+        const sentences = compressed.split(/[.!?]+/);
+        const uniqueSentences = [...new Set(sentences)];
+        compressed = uniqueSentences.join('. ');
+        // 3. Remove filler words (carefully)
+        const fillerWords = /\b(very|really|actually|basically|literally|just)\b/gi;
+        compressed = compressed.replace(fillerWords, '');
+        // 4. Compress common patterns
+        compressed = compressed
+            .replace(/in order to/gi, 'to')
+            .replace(/as well as/gi, 'and')
+            .replace(/at this point in time/gi, 'now')
+            .replace(/due to the fact that/gi, 'because');
+        // Track compression
+        this.metrics.tokensCompressed += prompt.length;
+        this.metrics.tokensSaved += prompt.length - compressed.length;
+        return compressed;
+    }
+    /**
+     * Optimize a single request
+     */
+    async optimizeSingle(request) {
+        // ⚠️ CACHE DISABLED - Caching removed for simplicity at MCP scale
+        // Cache was causing bugs (storing inputs instead of outputs) and maintenance overhead
+        // not justified for 10-50 runs/day. See: ultrathinking analysis 2025-10-18
+        // // 1. Check cache first (DISABLED)
+        // const cached = this.checkCache(request);
+        // if (cached) {
+        //   return {
+        //     ...request,
+        //     prompt: cached.response,
+        //     optimized: true,
+        //     fromCache: true,
+        //   };
+        // }
+        // 2. Compress if needed
+        const originalLength = request.prompt.length;
+        let optimizedPrompt = request.prompt;
+        if (originalLength > this.config.compressionThreshold) {
+            optimizedPrompt = await this.compressPrompt(request.prompt);
+        }
+        return {
+            ...request,
+            prompt: optimizedPrompt,
+            optimized: true,
+            compressed: optimizedPrompt !== request.prompt,
+            originalLength,
+            compressedLength: optimizedPrompt.length,
+        };
+    }
+    /**
+     * Add request to batch queue
+     */
+    async addToBatch(request) {
+        return new Promise((resolve, reject) => {
+            this.batchQueue.push({ request, resolve, reject });
+            // Process immediately if batch is full
+            if (this.batchQueue.length >= this.config.maxBatchSize) {
+                this.processBatch();
+            }
+            else {
+                // Otherwise wait for batch window
+                if (!this.batchTimer) {
+                    this.batchTimer = setTimeout(() => {
+                        this.processBatch();
+                    }, this.config.batchWindow);
+                }
+            }
+        });
+    }
+    /**
+     * Process batched requests
+     */
+    async processBatch() {
+        if (this.batchQueue.length === 0)
+            return;
+        // Clear timer
+        if (this.batchTimer) {
+            clearTimeout(this.batchTimer);
+            this.batchTimer = null;
+        }
+        // Extract batch
+        const batch = this.batchQueue.splice(0, this.config.maxBatchSize);
+        const batchId = crypto.randomBytes(8).toString('hex');
+        this.metrics.batchesProcessed++;
+        // Process each request in batch
+        for (const item of batch) {
+            try {
+                const optimized = await this.optimizeSingle(item.request);
+                item.resolve({
+                    ...optimized,
+                    batchId,
+                });
+            }
+            catch (error) {
+                item.reject(error);
+            }
+        }
+    }
+    /**
+     * Main optimization entry point
+     */
+    async optimize(request) {
+        // Check if request can be batched
+        if (request.canBatch && !this.checkCache(request)) {
+            return this.addToBatch(request);
+        }
+        // Otherwise optimize individually
+        return this.optimizeSingle(request);
+    }
+    /**
+     * Get optimization metrics
+     */
+    getMetrics() {
+        const cacheHitRate = this.metrics.cacheHits / (this.metrics.cacheHits + this.metrics.cacheMisses) || 0;
+        const compressionRatio = this.metrics.tokensSaved / this.metrics.tokensCompressed || 0;
+        const recommendations = [];
+        if (cacheHitRate < 0.3) {
+            recommendations.push(`⚠️ Low cache hit rate (${(cacheHitRate * 100).toFixed(1)}%). Consider caching more aggressively.`);
+        }
+        if (compressionRatio < 0.2) {
+            recommendations.push('💡 Compression ratio is low. Consider more aggressive compression.');
+        }
+        if (this.metrics.batchesProcessed < 10) {
+            recommendations.push('📊 Low batch usage. Enable batching for parallel requests.');
+        }
+        if (cacheHitRate > 0.7) {
+            recommendations.push('✅ Excellent cache performance!');
+        }
+        return {
+            cacheHitRate,
+            compressionRatio,
+            totalSaved: this.metrics.tokensSaved,
+            batchesProcessed: this.metrics.batchesProcessed,
+            recommendations,
+        };
+    }
+    /**
+     * Clear cache if it gets too large
+     */
+    maintainCache() {
+        if (this.responseCache.size > 900) {
+            // Keep 80% of most recently used
+            const toKeep = Math.floor(this.responseCache.size * 0.8);
+            while (this.responseCache.size > toKeep) {
+                const oldestKey = this.responseCache.keys().next().value;
+                if (oldestKey) {
+                    this.responseCache.delete(oldestKey);
+                }
+                else {
+                    break;
+                }
+            }
+        }
+    }
+    /**
+     * Reset all metrics
+     */
+    resetMetrics() {
+        this.metrics = {
+            cacheHits: 0,
+            cacheMisses: 0,
+            tokensCompressed: 0,
+            tokensSaved: 0,
+            batchesProcessed: 0,
+        };
+    }
+    /**
+     * Shutdown optimizer (cleanup)
+     */
+    shutdown() {
+        if (this.batchTimer) {
+            clearTimeout(this.batchTimer);
+            this.batchTimer = null;
+        }
+        this.processBatch(); // Process any remaining batched requests
+    }
+}
+// Export singleton instance
+export const tokenOptimizer = new TokenOptimizer();