adaptive-memory-multi-model-router 2.14.16 → 2.14.18

package/dist/routing/routing/advancedRouter.d.ts

@@ -0,0 +1,62 @@
+/**
+ * A3M Router - Generic Adaptive Routing (RouteLLM Style)
+ *
+ * Routes queries to the best available LLM based on:
+ * - Query features (code, math, creative, etc.)
+ * - Provider availability (checks API keys)
+ * - Cost optimization
+ * - Quality vs speed tradeoff
+ *
+ * All provider references are dynamically loaded from providerConfig.
+ * Users can add/remove providers via environment variables or config files.
+ */
+interface ModelProfile {
+    name: string;
+    provider: string;
+    providerName: string;
+    cost_per_1k_input: number;
+    cost_per_1k_output: number;
+    latency_ms: number;
+    quality_score: number;
+    strengths: string[];
+    context_window: number;
+    type: string;
+    priority: number;
+}
+export declare let MODEL_PROFILES: Record<string, ModelProfile>;
+export interface QueryFeatures {
+    length: number;
+    wordCount: number;
+    complexity: number;
+    has_code: boolean;
+    requires_reasoning: boolean;
+    is_multilingual: boolean;
+    is_translation: boolean;
+    domain: string | null;
+    intent: string;
+    detected_language: string | null;
+}
+export interface RouteDecision {
+    primary_model: string | null;
+    fallback_models: string[];
+    confidence: number;
+    reasoning: string;
+    estimated_cost: number;
+    estimated_latency_ms: number;
+    features?: QueryFeatures;
+    provider_type?: string;
+}
+export declare function routeQuery(prompt: string, available_models?: string[], budget_multiplier?: number): RouteDecision;
+export declare function routeBatch(prompts: string[], options?: {
+    same_model?: boolean;
+    max_cost_per_prompt?: number;
+}): RouteDecision[];
+export declare function recommendForTask(task: string): {
+    primary: string | null;
+    fallbacks: string[];
+    reason: string;
+    features: QueryFeatures;
+};
+export declare function updateModelProfile(model_name: string, actual_latency_ms: number, actual_cost: number, quality_rating: number): void;
+export declare function getProviderHealth(): Promise<any>;
+export {};

package/dist/routing/routing/advancedRouter.js

@@ -0,0 +1,447 @@
+"use strict";
+/**
+ * A3M Router - Generic Adaptive Routing (RouteLLM Style)
+ *
+ * Routes queries to the best available LLM based on:
+ * - Query features (code, math, creative, etc.)
+ * - Provider availability (checks API keys)
+ * - Cost optimization
+ * - Quality vs speed tradeoff
+ *
+ * All provider references are dynamically loaded from providerConfig.
+ * Users can add/remove providers via environment variables or config files.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODEL_PROFILES = void 0;
+exports.routeQuery = routeQuery;
+exports.routeBatch = routeBatch;
+exports.recommendForTask = recommendForTask;
+exports.updateModelProfile = updateModelProfile;
+exports.getProviderHealth = getProviderHealth;
+const providerConfig_1 = require("../providers/providerConfig");
+const tokenUtils_1 = require("../utils/tokenUtils");
+let cachedProfiles = null;
+let cacheTimestamp = 0;
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+function buildModelProfiles() {
+    const profiles = {};
+    const available = (0, providerConfig_1.getAvailableProviders)();
+    for (const [providerId, provider] of Object.entries(available)) {
+        for (const model of provider.models) {
+            const modelKey = model.includes('/') ? model : providerId + '/' + model;
+            const costPerKInput = provider.costPerK ? provider.costPerK.input : 0;
+            const costPerKOutput = provider.costPerK ? provider.costPerK.output : 0;
+            // Assign strengths based on model characteristics
+            const strengths = [];
+            if (provider.type === 'cli') {
+                strengths.push('free', 'local');
+            }
+            if (costPerKInput < 0.3) {
+                strengths.push('budget', 'fast');
+            }
+            else if (costPerKInput > 2) {
+                strengths.push('premium', 'reasoning');
+            }
+            if (provider.name === 'Mistral' || provider.name === 'Groq' || provider.name === 'Cerebras') {
+                strengths.push('fast', 'coding');
+            }
+            if (provider.name === 'CommandCode') {
+                strengths.push('code-aware', 'context-rich');
+            }
+            if (provider.name === 'OpenCode') {
+                strengths.push('free', 'multi-model');
+            }
+            if (provider.name === 'Google') {
+                strengths.push('multilingual', 'long-context');
+            }
+            if (provider.name === 'OpenAI') {
+                strengths.push('reasoning', 'coding', 'analysis');
+            }
+            if (provider.name === 'Anthropic') {
+                strengths.push('reasoning', 'creative', 'analysis');
+            }
+            profiles[modelKey] = {
+                name: modelKey,
+                provider: providerId,
+                providerName: provider.name,
+                cost_per_1k_input: costPerKInput,
+                cost_per_1k_output: costPerKOutput,
+                latency_ms: provider.type === 'cli' ? 5000 : (provider.priority * 200 + 300),
+                quality_score: strengths.includes('premium') ? 0.95 :
+                    strengths.includes('reasoning') ? 0.90 :
+                        strengths.includes('fast') ? 0.82 : 0.80,
+                strengths,
+                context_window: provider.maxTokens || 8192,
+                type: provider.type,
+                priority: provider.priority,
+            };
+        }
+    }
+    return profiles;
+}
+// Lazy cache with TTL - replaces refreshModelProfiles()
+function getModelProfiles() {
+    const now = Date.now();
+    if (!cachedProfiles || (now - cacheTimestamp) > CACHE_TTL_MS) {
+        cachedProfiles = buildModelProfiles();
+        cacheTimestamp = now;
+    }
+    return cachedProfiles;
+}
+// Manual cache invalidation (call if provider config changes)
+function invalidateProfileCache() {
+    cachedProfiles = null;
+    cacheTimestamp = 0;
+}
+exports.MODEL_PROFILES = {};
+try {
+    exports.MODEL_PROFILES = buildModelProfiles();
+}
+catch (e) {
+    // Circular dependency at module load — will retry on first use
+    exports.MODEL_PROFILES = {};
+}
+function extractQueryFeatures(prompt) {
+    const lower = prompt.toLowerCase();
+    const words = prompt.split(/\s+/);
+    const wordCount = words.length;
+    // === SIGNAL 1: Domain Detection ===
+    const domainSignals = {
+        legal: {
+            keywords: ['legal', 'law', 'contract', 'liability', 'litigation', 'patent', 'copyright',
+                'regulation', 'compliance', 'constitutional', 'statute', 'jurisdiction',
+                'court', 'ruling', 'precedent', 'attorney', 'amicus', 'sec ', 'fda ',
+                'gdpr', 'ccpa', 'cfpr', 'due diligence', 'merger', 'acquisition',
+                '10-k', 'sec filing', 'forensic', 'embezzlement', 'infringement'],
+            weight: 0.35
+        },
+        medical: {
+            keywords: ['clinical', 'medical', 'pharmaceutical', 'oncology', 'drug', 'trial protocol',
+                'diagnosis', 'treatment', 'epidemiolog', 'genome', 'cohort study',
+                'biomarker', 'efficacy', 'pharmacoeconomic', 'biologic', 'vaccine',
+                'sepsis', 'ehr ', 'surgical', 'patient safety', 'fda approval'],
+            weight: 0.35
+        },
+        finance: {
+            keywords: ['financial model', 'valuation', 'revenue', 'portfolio', 'derivative',
+                'hedge fund', 'series a', 'series b', 'startup valuation', 'sensitivity analysis',
+                'investment thesis', 'earnings', 'tax optimization', 'forensic accounting',
+                'multinational', 'jurisdiction', 'risk assessment', 'monte carlo',
+                'black-scholes', 'options pricing', 'credit risk'],
+            weight: 0.30
+        },
+        security: {
+            keywords: ['security audit', 'penetration', 'vulnerability', 'exploit', 'zero-trust',
+                'threat model', 'incident response', 'malware', 'ransomware',
+                'authentication flow', 'cryptograph', 'encryption', 'timing attack',
+                'supply chain attack', 'owasp', 'compliance', 'risk assessment',
+                'mfa', 'zero-day', 'firewall', 'intrusion'],
+            weight: 0.30
+        },
+        architecture: {
+            keywords: ['system design', 'microservice', 'distributed system', 'fault-tolerant',
+                'event-sourced', 'cqrs', 'consensus algorithm', 'real-time pipeline',
+                'high availability', 'multi-region', 'latency sla', 'kafka',
+                'event-driven', 'data warehouse', 'etl', 'streaming', '1m events',
+                'million events', 'scalab', 'infrastruct', 'deploy'],
+            weight: 0.25
+        },
+        data_science: {
+            keywords: ['machine learning', 'deep learning', 'neural network', 'transformer',
+                'training data', 'model accuracy', 'hyperparameter', 'cross-validation',
+                'feature engineering', 'data pipeline', 'pandas', 'numpy', 'scikit',
+                'tensorflow', 'pytorch', 'regression', 'classification', 'clustering'],
+            weight: 0.30
+        },
+    };
+    let detectedDomain = null;
+    let maxDomainScore = 0;
+    for (const [domain, signal] of Object.entries(domainSignals)) {
+        let domainScore = 0;
+        for (const kw of signal.keywords) {
+            if (lower.includes(kw)) {
+                domainScore += signal.weight;
+            }
+        }
+        if (domainScore > maxDomainScore) {
+            maxDomainScore = domainScore;
+            detectedDomain = domain;
+        }
+    }
+    // === SIGNAL 2: Code Detection ===
+    const codeSignals = [
+        'function ', 'def ', 'class ', 'import ', 'from ', 'const ', 'let ', 'var ',
+        '=>', '->', 'async ', 'await ', 'return ', 'if (', 'for (', 'while (',
+        'public ', 'private ', 'protected ', 'static ', 'void ', 'int ', 'string ',
+        '#include', 'std::', 'cout', 'cin', 'printf(', 'println!',
+        'fn ', 'impl ', 'pub ', 'mut ', 'struct ', 'enum ',
+        '```', 'code', 'python', 'javascript', 'typescript', 'java', 'cpp', 'ruby',
+        'write a', 'create a', 'implement', 'algorithm'
+    ];
+    const hasCode = codeSignals.some(sig => lower.includes(sig));
+    // === SIGNAL 3: Reasoning Detection ===
+    const reasoningSignals = [
+        'why', 'how', 'explain', 'analyze', 'compare', 'contrast', 'evaluate',
+        'think about', 'reason', 'logic', 'proof', 'derive', '证明', '分析',
+        'reasoning', 'step by step', 'thinking', 'thought process'
+    ];
+    const requiresReasoning = reasoningSignals.some(sig => lower.includes(sig));
+    // === SIGNAL 4: Language Detection ===
+    const languagePatterns = [
+        [/[\u4e00-\u9fff]/, 'zh'],
+        [/[\u0900-\u097f]/, 'hi'],
+        [/[\u0600-\u06ff]/, 'ar'],
+        [/[\u0400-\u04ff]/, 'ru'],
+        [/[\u0900-\u097f]/, 'hi-latn'],
+        [/বাংলা|করুন|হিন্দি|ভারত|ভারতীয়/, 'bn'],
+    ];
+    let detectedLanguage = null;
+    for (const [pattern, lang] of languagePatterns) {
+        if (pattern.test(prompt)) {
+            detectedLanguage = lang;
+            break;
+        }
+    }
+    // Translation detection
+    const translationSignals = ['translate', 'translation', 'into english', 'to english',
+        'traducir', 'traduction', 'traduzione', 'übersetzen'];
+    const isTranslation = translationSignals.some(sig => lower.includes(sig)) ||
+        /to (english|french|german|spanish|chinese|japanese|korean)/i.test(prompt);
+    const isMultilingual = detectedLanguage !== null || isTranslation;
+    // === SIGNAL 5: Intent Classification ===
+    let intent = 'general';
+    if (hasCode)
+        intent = 'code';
+    else if (isTranslation)
+        intent = 'translation';
+    else if (lower.includes('write') || lower.includes('create') || lower.includes('generate')) {
+        intent = 'creative';
+    }
+    else if (lower.includes('explain') || lower.includes('what is') || lower.includes('how does')) {
+        intent = 'explanation';
+    }
+    else if (lower.includes('calculate') || lower.includes('compute') || lower.includes('integral')) {
+        intent = 'math';
+    }
+    // === COMPLEXITY SCORING ===
+    // Base complexity from length
+    let complexity = Math.min(wordCount / 100, 1.0);
+    // Domain加成
+    if (detectedDomain)
+        complexity += 0.2;
+    // Code加成
+    if (hasCode)
+        complexity += 0.15;
+    // Reasoning加成
+    if (requiresReasoning)
+        complexity += 0.15;
+    // Multilingual加成
+    if (isMultilingual)
+        complexity += 0.1;
+    // Cap at 1.0
+    complexity = Math.min(complexity, 1.0);
+    return {
+        length: prompt.length,
+        wordCount,
+        complexity,
+        has_code: hasCode,
+        requires_reasoning: requiresReasoning,
+        is_multilingual: isMultilingual,
+        is_translation: isTranslation,
+        domain: detectedDomain,
+        intent,
+        detected_language: detectedLanguage,
+    };
+}
+function scoreModelFit(model, features) {
+    let score = model.quality_score * 0.6;
+    // Domain match
+    if (features.domain) {
+        const domainBonus = {
+            code: ['code-aware', 'coding', 'fast'],
+            medical: ['reasoning', 'analysis'],
+            legal: ['reasoning', 'analysis', 'context-rich'],
+            finance: ['analysis', 'reasoning'],
+            security: ['reasoning', 'analysis'],
+            architecture: ['context-rich', 'long-context'],
+            data_science: ['coding', 'fast', 'reasoning'],
+        };
+        const bonuses = domainBonus[features.domain] || [];
+        if (bonuses.some(b => model.strengths.includes(b))) {
+            score += 0.2;
+        }
+    }
+    // Code bonus
+    if (features.has_code && model.strengths.includes('coding')) {
+        score += 0.15;
+    }
+    // Multilingual bonus
+    if (features.is_multilingual && model.strengths.includes('multilingual')) {
+        score += 0.15;
+    }
+    // Free tier preference for simple queries
+    if (features.complexity < 0.5 && model.strengths.includes('free')) {
+        score += 0.2;
+    }
+    // Fast provider for simple queries
+    if (features.complexity < 0.4 && model.strengths.includes('fast')) {
+        score += 0.15;
+    }
+    // Premium for complex queries
+    if (features.complexity > 0.6 && model.strengths.includes('premium')) {
+        score += 0.15;
+    }
+    return Math.min(score, 1.0);
+}
+function costEfficiency(model, features) {
+    const avg_cost = (model.cost_per_1k_input + model.cost_per_1k_output) / 2;
+    if (features.complexity < 0.5) {
+        return (1 - Math.min(avg_cost / 10, 1)) * 0.6;
+    }
+    return (1 - Math.min(avg_cost / 10, 1)) * 0.2;
+}
+function routeQuery(prompt, available_models, budget_multiplier = 1.0) {
+    // Use cached profiles instead of rebuilding every time (5-10ms savings)
+    const profiles = getModelProfiles();
+    const features = extractQueryFeatures(prompt);
+    const candidate_names = available_models || Object.keys(profiles);
+    // Filter to available models
+    const candidates = candidate_names
+        .filter(name => profiles[name])
+        .map(name => {
+        const profile = profiles[name];
+        const quality = scoreModelFit(profile, features);
+        const cost = costEfficiency(profile, features);
+        return {
+            name,
+            profile,
+            quality_score: quality,
+            cost_score: cost,
+            total_score: quality + cost
+        };
+    });
+    if (candidates.length === 0) {
+        return {
+            primary_model: null,
+            fallback_models: [],
+            confidence: 0,
+            reasoning: "No providers available - configure API keys in ~/.config/a3m-router/providers.json",
+            estimated_cost: 0,
+            estimated_latency_ms: 0,
+        };
+    }
+    // Sort by total score (quality vs cost tradeoff based on complexity)
+    const complexity_bias = features.complexity > 0.6 ? 0.7 : 0.3;
+    candidates.sort((a, b) => {
+        const score_a = a.quality_score * complexity_bias + a.cost_score * (1 - complexity_bias);
+        const score_b = b.quality_score * complexity_bias + b.cost_score * (1 - complexity_bias);
+        return score_b - score_a;
+    });
+    const primary = candidates[0];
+    const secondary = candidates.slice(1, 3);
+    // Calculate confidence based on score gap
+    let confidence = 0.5;
+    if (candidates.length > 1) {
+        const gap = primary.total_score - candidates[1].total_score;
+        confidence = Math.min(0.95, 0.5 + gap * 2);
+    }
+    // Build reasoning
+    const reasons = [];
+    if (features.has_code)
+        reasons.push("code detected");
+    if (features.requires_reasoning)
+        reasons.push("reasoning needed");
+    if (features.complexity > 0.6)
+        reasons.push("high complexity");
+    if (features.is_multilingual)
+        reasons.push("multilingual");
+    if (features.is_translation)
+        reasons.push("translation");
+    if (primary.profile.strengths.includes("free"))
+        reasons.push("free tier");
+    const estimated_tokens = features.length * 1.5;
+    const estimated_cost = (0, tokenUtils_1.estimateCost)(features.length, estimated_tokens, primary.name);
+    return {
+        primary_model: primary.name,
+        fallback_models: secondary.map(c => c.name),
+        confidence,
+        reasoning: `Selected ${primary.profile.providerName || primary.profile.provider}/${primary.name} for ${reasons.join(", ") || "general query"}`,
+        estimated_cost: estimated_cost * budget_multiplier,
+        estimated_latency_ms: primary.profile.latency_ms,
+        features,
+        provider_type: primary.profile.type,
+    };
+}
+// ============================================================
+// BATCH ROUTING
+// ============================================================
+function routeBatch(prompts, options = {}) {
+    const decisions = prompts.map(p => routeQuery(p));
+    if (options.same_model && decisions.length > 0) {
+        const primary_model = decisions[0].primary_model;
+        decisions.forEach(d => {
+            d.primary_model = primary_model;
+            d.fallback_models = decisions[0].fallback_models;
+        });
+    }
+    if (options.max_cost_per_prompt !== undefined) {
+        const profiles = getModelProfiles();
+        decisions.forEach(d => {
+            if (d.estimated_cost > options.max_cost_per_prompt) {
+                const cheap = Object.entries(profiles)
+                    .find(([name, p]) => p.cost_per_1k_input < 0.5);
+                if (cheap) {
+                    d.primary_model = cheap[0];
+                    d.reasoning = `Budget-limited routing to ${cheap[1].providerName || cheap[1].provider}`;
+                }
+            }
+        });
+    }
+    return decisions;
+}
+// ============================================================
+// TASK RECOMMENDATIONS
+// ============================================================
+function recommendForTask(task) {
+    const features = extractQueryFeatures(task);
+    const decision = routeQuery(task);
+    return {
+        primary: decision.primary_model,
+        fallbacks: decision.fallback_models,
+        reason: decision.reasoning,
+        features,
+    };
+}
+// ============================================================
+// ONLINE LEARNING - Update model profiles from feedback
+// ============================================================
+function updateModelProfile(model_name, actual_latency_ms, actual_cost, quality_rating) {
+    const profiles = getModelProfiles();
+    const profile = profiles[model_name];
+    if (!profile)
+        return;
+    const alpha = 0.2; // Learning rate
+    profile.latency_ms = profile.latency_ms * (1 - alpha) + actual_latency_ms * alpha;
+    profile.quality_score = profile.quality_score * (1 - alpha) + quality_rating * alpha;
+}
+// ============================================================
+// PROVIDER HEALTH CHECK
+// ============================================================
+async function getProviderHealth() {
+    const { checkAllProviders } = require("../providers/providerConfig");
+    return checkAllProviders();
+}
+// ============================================================
+// Default export
+// ============================================================
+module.exports = {
+    extractQueryFeatures,
+    routeQuery,
+    routeBatch,
+    recommendForTask,
+    updateModelProfile,
+    getProviderHealth,
+    MODEL_PROFILES: exports.MODEL_PROFILES,
+    invalidateProfileCache,
+};
+module.exports.default = module.exports;

package/dist/routing/utils/tokenUtils.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Token counting utilities for provider cost estimation
+ */
+export interface TokenCost {
+    input_per_1k: number;
+    output_per_1k: number;
+}
+export declare const MODEL_COSTS: Record<string, TokenCost>;
+/**
+ * Count tokens in text (approximate for English).
+ * Based on ~1.3 tokens per word for typical English text.
+ */
+export declare function countTokens(text: string, model?: string): number;
+/**
+ * Alias for countTokens for backward compatibility.
+ */
+export declare function estimateTokens(text: string): number;
+/**
+ * Estimate cost for a prompt/completion pair.
+ */
+export declare function estimateCost(prompt_tokens: number, completion_tokens: number, model: string): number;
+/**
+ * Estimate cost from raw text (approximates both prompt and completion).
+ */
+export declare function estimateCostFromText(prompt: string, completion: string, model: string): number;
+/**
+ * Get cost info for a model.
+ */
+export declare function getModelCost(model: string): TokenCost;
+/**
+ * List all supported models with their costs.
+ */
+export declare function listModelsByCost(): Array<{
+    model: string;
+    input: number;
+    output: number;
+}>;
+/**
+ * Find cheapest models for a given task.
+ */
+export declare function findCheapestModels(task: "fast" | "quality" | "balanced" | "coding", count?: number): string[];
+declare const _default: {
+    countTokens: typeof countTokens;
+    estimateTokens: typeof estimateTokens;
+    estimateCost: typeof estimateCost;
+    estimateCostFromText: typeof estimateCostFromText;
+    getModelCost: typeof getModelCost;
+    listModelsByCost: typeof listModelsByCost;
+    findCheapestModels: typeof findCheapestModels;
+    MODEL_COSTS: Record<string, TokenCost>;
+};
+export default _default;

package/dist/routing/utils/tokenUtils.js

@@ -0,0 +1,129 @@
+"use strict";
+/**
+ * Token counting utilities for provider cost estimation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODEL_COSTS = void 0;
+exports.countTokens = countTokens;
+exports.estimateTokens = estimateTokens;
+exports.estimateCost = estimateCost;
+exports.estimateCostFromText = estimateCostFromText;
+exports.getModelCost = getModelCost;
+exports.listModelsByCost = listModelsByCost;
+exports.findCheapestModels = findCheapestModels;
+// Current provider rates (2024-2025)
+exports.MODEL_COSTS = {
+    // OpenAI
+    "gpt-4o": { input_per_1k: 2.50, output_per_1k: 10.00 },
+    "gpt-4o-mini": { input_per_1k: 0.15, output_per_1k: 0.60 },
+    "gpt-4-turbo": { input_per_1k: 10.00, output_per_1k: 30.00 },
+    "gpt-3.5-turbo": { input_per_1k: 0.50, output_per_1k: 1.50 },
+    // Anthropic
+    "claude-3.5-sonnet": { input_per_1k: 3.00, output_per_1k: 15.00 },
+    "claude-3-opus": { input_per_1k: 15.00, output_per_1k: 75.00 },
+    "claude-3-haiku": { input_per_1k: 0.25, output_per_1k: 1.25 },
+    // Google
+    "gemini-2.0-flash": { input_per_1k: 0.00, output_per_1k: 0.00 }, // Free
+    "gemini-1.5-pro": { input_per_1k: 1.25, output_per_1k: 5.00 },
+    "gemini-1.5-flash": { input_per_1k: 0.075, output_per_1k: 0.30 },
+    // Groq
+    "groq/llama-3.3-70b": { input_per_1k: 0.59, output_per_1k: 0.79 },
+    "groq/llama-3.1-8b": { input_per_1k: 0.05, output_per_1k: 0.08 },
+    // Cerebras
+    "cerebras/llama-3.3-70b": { input_per_1k: 0.60, output_per_1k: 0.60 },
+    // Mistral
+    "mistral-large": { input_per_1k: 2.00, output_per_1k: 6.00 },
+    "mistral-small": { input_per_1k: 0.20, output_per_1k: 0.60 },
+};
+/**
+ * Count tokens in text (approximate for English).
+ * Based on ~1.3 tokens per word for typical English text.
+ */
+function countTokens(text, model = "gpt-4o") {
+    if (!text || text.length === 0)
+        return 0;
+    // Use model-specific approximation if available
+    // Otherwise use generic word-based estimate
+    const words = text.trim().split(/\s+/).length;
+    // Fine-tune based on model family
+    if (model.includes("claude")) {
+        // Anthropic models: ~1.5 tokens per word
+        return Math.ceil(words * 1.5);
+    }
+    else if (model.includes("gemini")) {
+        // Google: ~1.2 tokens per word (SentencePiece)
+        return Math.ceil(words * 1.2);
+    }
+    else if (model.includes("llama")) {
+        // Llama: ~1.4 tokens per word (BPE)
+        return Math.ceil(words * 1.4);
+    }
+    // Default: ~1.3 tokens per word (GPT-4 average)
+    return Math.ceil(words * 1.3);
+}
+/**
+ * Alias for countTokens for backward compatibility.
+ */
+function estimateTokens(text) {
+    return countTokens(text);
+}
+/**
+ * Estimate cost for a prompt/completion pair.
+ */
+function estimateCost(prompt_tokens, completion_tokens, model) {
+    const costs = exports.MODEL_COSTS[model] || exports.MODEL_COSTS["gpt-4o"];
+    const input_cost = (prompt_tokens / 1000) * costs.input_per_1k;
+    const output_cost = (completion_tokens / 1000) * costs.output_per_1k;
+    return input_cost + output_cost;
+}
+/**
+ * Estimate cost from raw text (approximates both prompt and completion).
+ */
+function estimateCostFromText(prompt, completion, model) {
+    const prompt_tokens = countTokens(prompt, model);
+    // Completion typically has higher token density
+    const completion_tokens = Math.ceil(countTokens(completion, model) * 1.2);
+    return estimateCost(prompt_tokens, completion_tokens, model);
+}
+/**
+ * Get cost info for a model.
+ */
+function getModelCost(model) {
+    return exports.MODEL_COSTS[model] || exports.MODEL_COSTS["gpt-4o"];
+}
+/**
+ * List all supported models with their costs.
+ */
+function listModelsByCost() {
+    return Object.entries(exports.MODEL_COSTS)
+        .map(([model, cost]) => ({
+        model,
+        input: cost.input_per_1k,
+        output: cost.output_per_1k
+    }))
+        .sort((a, b) => (a.input + a.output) - (b.input + b.output));
+}
+/**
+ * Find cheapest models for a given task.
+ */
+function findCheapestModels(task, count = 3) {
+    const sorted = listModelsByCost();
+    // Different profiles for different needs
+    const profiles = {
+        fast: sorted.filter(m => m.output < 1.0).slice(0, count).map(m => m.model),
+        quality: sorted.filter(m => m.output > 10).slice(0, count).map(m => m.model),
+        balanced: sorted.slice(0, count * 2).slice(count, count * 2).map(m => m.model),
+        coding: sorted.filter(m => m.model.includes("codex") || m.model.includes("claude") || m.model.includes("llama")).slice(0, count).map(m => m.model)
+    };
+    return profiles[task] || profiles.balanced;
+}
+exports.default = {
+    countTokens,
+    estimateTokens,
+    estimateCost,
+    estimateCostFromText,
+    getModelCost,
+    listModelsByCost,
+    findCheapestModels,
+    MODEL_COSTS: exports.MODEL_COSTS
+};