@blockrun/cc 0.8.2 → 0.9.1

package/dist/proxy/server.js

@@ -1,8 +1,24 @@
 import http from 'node:http';
-import { getOrCreateWallet, getOrCreateSolanaWallet, createPaymentPayload, createSolanaPaymentPayload, parsePaymentRequired, extractPaymentDetails, solanaKeyToBytes, SOLANA_NETWORK, } from '@blockrun/llm';
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { getOrCreateWallet, getOrCreateSolanaWallet, createPaymentPayload, createSolanaPaymentPayload, parsePaymentRequired, extractPaymentDetails, solanaKeyToBytes, SOLANA_NETWORK, } from '@blockrun/llm';
+import { recordUsage } from '../stats/tracker.js';
+import { fetchWithFallback, buildFallbackChain, DEFAULT_FALLBACK_CONFIG, } from './fallback.js';
+import { routeRequest, parseRoutingProfile, } from '../router/index.js';
+// Get version from package.json
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+let VERSION = '0.9.0';
+try {
+    const pkgPath = path.resolve(__dirname, '../../package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    VERSION = pkg.version || VERSION;
+}
+catch { /* use default */ }
+// User-Agent for backend requests
+const USER_AGENT = `brcc/${VERSION}`;
+const X_BRCC_VERSION = VERSION;
 const LOG_FILE = path.join(os.homedir(), '.blockrun', 'brcc-debug.log');
 function debug(options, ...args) {
     if (!options.debug)
@@ -12,27 +28,64 @@ function debug(options, ...args) {
         fs.mkdirSync(path.dirname(LOG_FILE), { recursive: true });
         fs.appendFileSync(LOG_FILE, msg);
     }
-    catch { /* ignore */ }
+    catch {
+        /* ignore */
+    }
+}
+function log(...args) {
+    const msg = `[brcc] ${args.map(String).join(' ')}`;
+    console.log(msg);
 }
 const DEFAULT_MAX_TOKENS = 4096;
 let lastOutputTokens = 0;
 // Model shortcuts for quick switching
 const MODEL_SHORTCUTS = {
-    'gpt': 'openai/gpt-5.4',
-    'gpt5': 'openai/gpt-5.4',
+    auto: 'blockrun/auto',
+    smart: 'blockrun/auto',
+    eco: 'blockrun/eco',
+    premium: 'blockrun/premium',
+    gpt: 'openai/gpt-5.4',
+    gpt5: 'openai/gpt-5.4',
     'gpt-5': 'openai/gpt-5.4',
     'gpt-5.4': 'openai/gpt-5.4',
-    'sonnet': 'anthropic/claude-sonnet-4.6',
-    'claude': 'anthropic/claude-sonnet-4.6',
-    'opus': 'anthropic/claude-opus-4.6',
-    'haiku': 'anthropic/claude-haiku-4.5',
-    'deepseek': 'deepseek/deepseek-chat',
-    'gemini': 'google/gemini-2.5-pro',
-    'grok': 'xai/grok-3',
-    'free': 'nvidia/gpt-oss-120b',
-    'mini': 'openai/gpt-5-mini',
-    'glm': 'zai/glm-5',
+    sonnet: 'anthropic/claude-sonnet-4.6',
+    claude: 'anthropic/claude-sonnet-4.6',
+    opus: 'anthropic/claude-opus-4.6',
+    haiku: 'anthropic/claude-haiku-4.5',
+    deepseek: 'deepseek/deepseek-chat',
+    gemini: 'google/gemini-2.5-pro',
+    grok: 'xai/grok-3',
+    free: 'nvidia/gpt-oss-120b',
+    mini: 'openai/gpt-5-mini',
+    glm: 'zai/glm-5',
 };
+// Model pricing (per 1M tokens) - used for stats
+const MODEL_PRICING = {
+    // Routing profiles (blended averages)
+    'blockrun/auto': { input: 0.8, output: 4.0 },
+    'blockrun/eco': { input: 0.2, output: 1.0 },
+    'blockrun/premium': { input: 3.0, output: 15.0 },
+    'blockrun/free': { input: 0, output: 0 },
+    // Individual models
+    'anthropic/claude-sonnet-4.6': { input: 3.0, output: 15.0 },
+    'anthropic/claude-opus-4.6': { input: 5.0, output: 25.0 },
+    'anthropic/claude-haiku-4.5': { input: 1.0, output: 5.0 },
+    'openai/gpt-5.4': { input: 2.5, output: 15.0 },
+    'openai/gpt-5-mini': { input: 0.25, output: 2.0 },
+    'google/gemini-2.5-pro': { input: 1.25, output: 10.0 },
+    'google/gemini-2.5-flash': { input: 0.3, output: 2.5 },
+    'deepseek/deepseek-chat': { input: 0.28, output: 0.42 },
+    'xai/grok-3': { input: 3.0, output: 15.0 },
+    'xai/grok-4-fast': { input: 0.2, output: 0.5 },
+    'nvidia/gpt-oss-120b': { input: 0, output: 0 },
+    'zai/glm-5': { input: 1.0, output: 3.2 },
+    'moonshot/kimi-k2.5': { input: 0.6, output: 3.0 },
+};
+function estimateCost(model, inputTokens, outputTokens) {
+    const pricing = MODEL_PRICING[model] || { input: 2.0, output: 10.0 };
+    return ((inputTokens / 1_000_000) * pricing.input +
+        (outputTokens / 1_000_000) * pricing.output);
+}
 function detectModelSwitch(parsed) {
     if (!parsed.messages || parsed.messages.length === 0)
         return null;
@@ -44,7 +97,7 @@ function detectModelSwitch(parsed) {
         content = last.content;
     }
     else if (Array.isArray(last.content)) {
-        const textBlock = last.content.find(b => b.type === 'text' && b.text);
+        const textBlock = last.content.find((b) => b.type === 'text' && b.text);
         if (textBlock && textBlock.text)
             content = textBlock.text;
     }
@@ -63,9 +116,12 @@ function detectModelSwitch(parsed) {
         return modelInput;
     return null;
 }
+// Default model - smart routing built-in
+const DEFAULT_MODEL = 'blockrun/auto';
 export function createProxy(options) {
     const chain = options.chain || 'base';
-    let currentModel = options.modelOverride || null;
+    let currentModel = options.modelOverride || DEFAULT_MODEL;
+    const fallbackEnabled = options.fallbackEnabled !== false; // Default true
     let baseWallet = null;
     let solanaWallet = null;
     if (chain === 'base') {
@@ -85,13 +141,16 @@ export function createProxy(options) {
             return;
         }
         await initSolana();
-        const path = req.url?.replace(/^\/api/, '') || '';
-        const targetUrl = `${options.apiUrl}${path}`;
+        const requestPath = req.url?.replace(/^\/api/, '') || '';
+        const targetUrl = `${options.apiUrl}${requestPath}`;
         let body = '';
+        const requestStartTime = Date.now();
         req.on('data', (chunk) => {
             body += chunk;
         });
         req.on('end', async () => {
+            let requestModel = currentModel || options.modelOverride || 'unknown';
+            let usedFallback = false;
             try {
                 debug(options, `request: ${req.method} ${req.url} currentModel=${currentModel || 'none'}`);
                 if (body) {
@@ -111,7 +170,12 @@ export function createProxy(options) {
                                 type: 'message',
                                 role: 'assistant',
                                 model: currentModel,
-                                content: [{ type: 'text', text: `Switched to **${currentModel}**. All subsequent requests will use this model.` }],
+                                content: [
+                                    {
+                                        type: 'text',
+                                        text: `Switched to **${currentModel}**. All subsequent requests will use this model.`,
+                                    },
+                                ],
                                 stop_reason: 'end_turn',
                                 stop_sequence: null,
                                 usage: { input_tokens: 0, output_tokens: 10 },
@@ -120,14 +184,53 @@ export function createProxy(options) {
                             res.end(JSON.stringify(fakeResponse));
                             return;
                         }
-                        // Apply model override
-                        if ((currentModel || options.modelOverride) && parsed.model) {
-                            parsed.model = currentModel || options.modelOverride;
+                        // Apply model override only if:
+                        // 1. User specified --model on CLI (options.modelOverride)
+                        // 2. User switched model in-session (currentModel set by "use X" command)
+                        // 3. Request has no model specified
+                        if (options.modelOverride && currentModel) {
+                            // CLI --model flag: always use this
+                            parsed.model = currentModel;
+                        }
+                        else if (!parsed.model) {
+                            // No model in request: use default
+                            parsed.model = currentModel || DEFAULT_MODEL;
+                        }
+                        // Otherwise: use the model from the request as-is
+                        requestModel = parsed.model || DEFAULT_MODEL;
+                        // Smart routing: if model is a routing profile, classify and route
+                        const routingProfile = parseRoutingProfile(requestModel);
+                        if (routingProfile) {
+                            // Extract user prompt for classification
+                            const userMessages = parsed.messages?.filter((m) => m.role === 'user') || [];
+                            const lastUserMsg = userMessages[userMessages.length - 1];
+                            let promptText = '';
+                            if (lastUserMsg) {
+                                if (typeof lastUserMsg.content === 'string') {
+                                    promptText = lastUserMsg.content;
+                                }
+                                else if (Array.isArray(lastUserMsg.content)) {
+                                    promptText = lastUserMsg.content
+                                        .filter((b) => b.type === 'text')
+                                        .map((b) => b.text)
+                                        .join('\n');
+                                }
+                            }
+                            // Route the request
+                            const routing = routeRequest(promptText, routingProfile);
+                            parsed.model = routing.model;
+                            requestModel = routing.model;
+                            log(`🧠 Smart routing: ${routingProfile} → ${routing.tier} → ${routing.model} ` +
+                                `(${(routing.savings * 100).toFixed(0)}% savings) [${routing.signals.join(', ')}]`);
                         }
-                        if (parsed.max_tokens) {
+                        {
                             const original = parsed.max_tokens;
                             const model = (parsed.model || '').toLowerCase();
-                            const modelCap = (model.includes('deepseek') || model.includes('haiku') || model.includes('gpt-oss')) ? 8192 : 16384;
+                            const modelCap = model.includes('deepseek') ||
+                                model.includes('haiku') ||
+                                model.includes('gpt-oss')
+                                ? 8192
+                                : 16384;
                             // Use max of (last output × 2, default 4096) capped by model limit
                             // This ensures short replies don't starve the next request
                             const adaptive = lastOutputTokens > 0
@@ -135,28 +238,57 @@ export function createProxy(options) {
                                 : DEFAULT_MAX_TOKENS;
                             parsed.max_tokens = Math.min(adaptive, modelCap);
                             if (original !== parsed.max_tokens) {
-                                debug(options, `max_tokens: ${original} → ${parsed.max_tokens} (last output: ${lastOutputTokens || 'none'})`);
+                                debug(options, `max_tokens: ${original || 'unset'} → ${parsed.max_tokens} (last output: ${lastOutputTokens || 'none'})`);
                             }
                         }
                         body = JSON.stringify(parsed);
                     }
-                    catch { /* not JSON, pass through */ }
+                    catch {
+                        /* not JSON, pass through */
+                    }
                 }
                 const headers = {
                     'Content-Type': 'application/json',
+                    'User-Agent': USER_AGENT,
+                    'X-Brcc-Version': X_BRCC_VERSION,
                 };
                 for (const [key, value] of Object.entries(req.headers)) {
                     if (key.toLowerCase() !== 'host' &&
                         key.toLowerCase() !== 'content-length' &&
+                        key.toLowerCase() !== 'user-agent' && // Don't forward client's user-agent
                         value) {
                         headers[key] = Array.isArray(value) ? value[0] : value;
                     }
                 }
-                let response = await fetch(targetUrl, {
+                // Build request init
+                const requestInit = {
                     method: req.method || 'POST',
                     headers,
                     body: body || undefined,
-                });
+                };
+                let response;
+                let finalModel = requestModel;
+                // Use fallback chain if enabled
+                if (fallbackEnabled && body && requestPath.includes('messages')) {
+                    const fallbackConfig = {
+                        ...DEFAULT_FALLBACK_CONFIG,
+                        chain: buildFallbackChain(requestModel),
+                    };
+                    const result = await fetchWithFallback(targetUrl, requestInit, body, fallbackConfig, (failedModel, status, nextModel) => {
+                        log(`⚠️  ${failedModel} returned ${status}, falling back to ${nextModel}`);
+                    });
+                    response = result.response;
+                    finalModel = result.modelUsed;
+                    usedFallback = result.fallbackUsed;
+                    if (usedFallback) {
+                        log(`↺ Fallback successful: using ${finalModel}`);
+                    }
+                }
+                else {
+                    // Direct fetch without fallback
+                    response = await fetch(targetUrl, requestInit);
+                }
+                // Handle 402 payment
                 if (response.status === 402) {
                     if (chain === 'solana' && solanaWallet) {
                         response = await handleSolanaPayment(response, targetUrl, req.method || 'POST', headers, body, solanaWallet.privateKey, solanaWallet.address);
@@ -175,22 +307,33 @@ export function createProxy(options) {
                     const reader = response.body.getReader();
                     const decoder = new TextDecoder();
                     let lastChunkText = '';
+                    let fullResponse = '';
                     const pump = async () => {
                         while (true) {
                             const { done, value } = await reader.read();
                             if (done) {
+                                // Record stats from streaming response
                                 if (isStreaming && lastChunkText) {
-                                    const match = lastChunkText.match(/"output_tokens"\s*:\s*(\d+)/);
-                                    if (match) {
-                                        lastOutputTokens = parseInt(match[1], 10);
-                                        debug(options, `recorded output_tokens: ${lastOutputTokens} (stream)`);
+                                    const outputMatch = lastChunkText.match(/"output_tokens"\s*:\s*(\d+)/);
+                                    const inputMatch = fullResponse.match(/"input_tokens"\s*:\s*(\d+)/);
+                                    if (outputMatch) {
+                                        lastOutputTokens = parseInt(outputMatch[1], 10);
+                                        const inputTokens = inputMatch
+                                            ? parseInt(inputMatch[1], 10)
+                                            : 0;
+                                        const latencyMs = Date.now() - requestStartTime;
+                                        const cost = estimateCost(finalModel, inputTokens, lastOutputTokens);
+                                        recordUsage(finalModel, inputTokens, lastOutputTokens, cost, latencyMs, usedFallback);
+                                        debug(options, `recorded: model=${finalModel} in=${inputTokens} out=${lastOutputTokens} cost=$${cost.toFixed(4)} fallback=${usedFallback}`);
                                     }
                                 }
                                 res.end();
                                 break;
                             }
                             if (isStreaming) {
-                                lastChunkText = decoder.decode(value, { stream: true });
+                                const chunk = decoder.decode(value, { stream: true });
+                                lastChunkText = chunk;
+                                fullResponse += chunk;
                             }
                             res.write(value);
                         }
@@ -203,15 +346,22 @@ export function createProxy(options) {
                         const parsed = JSON.parse(text);
                         if (parsed.usage?.output_tokens) {
                             lastOutputTokens = parsed.usage.output_tokens;
-                            debug(options, `recorded output_tokens: ${lastOutputTokens}`);
+                            const inputTokens = parsed.usage?.input_tokens || 0;
+                            const latencyMs = Date.now() - requestStartTime;
+                            const cost = estimateCost(finalModel, inputTokens, lastOutputTokens);
+                            recordUsage(finalModel, inputTokens, lastOutputTokens, cost, latencyMs, usedFallback);
+                            debug(options, `recorded: model=${finalModel} in=${inputTokens} out=${lastOutputTokens} cost=$${cost.toFixed(4)} fallback=${usedFallback}`);
                         }
                     }
-                    catch { /* not JSON */ }
+                    catch {
+                        /* not JSON */
+                    }
                     res.end(text);
                 }
             }
             catch (error) {
                 const msg = error instanceof Error ? error.message : 'Proxy error';
+                log(`❌ Error: ${msg}`);
                 res.writeHead(502, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({
                     type: 'error',
@@ -292,9 +442,12 @@ export function classifyRequest(body) {
                 .map((b) => b.text)
                 .join('\n');
         }
-        if (content.includes('```') || content.includes('function ') ||
-            content.includes('class ') || content.includes('import ') ||
-            content.includes('def ') || content.includes('const ')) {
+        if (content.includes('```') ||
+            content.includes('function ') ||
+            content.includes('class ') ||
+            content.includes('import ') ||
+            content.includes('def ') ||
+            content.includes('const ')) {
             return { category: 'code' };
         }
         if (content.length < 100) {

package/dist/router/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Smart Router for brcc
+ * Ported from ClawRouter - 15-dimension weighted scoring for tier classification
+ */
+export type Tier = 'SIMPLE' | 'MEDIUM' | 'COMPLEX' | 'REASONING';
+export type RoutingProfile = 'auto' | 'eco' | 'premium' | 'free';
+export interface RoutingResult {
+    model: string;
+    tier: Tier;
+    confidence: number;
+    signals: string[];
+    savings: number;
+}
+export declare function routeRequest(prompt: string, profile?: RoutingProfile): RoutingResult;
+/**
+ * Get fallback models for a tier
+ */
+export declare function getFallbackChain(tier: Tier, profile?: RoutingProfile): string[];
+/**
+ * Parse routing profile from model string
+ */
+export declare function parseRoutingProfile(model: string): RoutingProfile | null;

package/dist/router/index.js

@@ -0,0 +1,274 @@
+/**
+ * Smart Router for brcc
+ * Ported from ClawRouter - 15-dimension weighted scoring for tier classification
+ */
+// ─── Tier Model Configs ───
+const AUTO_TIERS = {
+    SIMPLE: {
+        primary: 'google/gemini-2.5-flash',
+        fallback: ['deepseek/deepseek-chat', 'nvidia/gpt-oss-120b'],
+    },
+    MEDIUM: {
+        primary: 'moonshot/kimi-k2.5',
+        fallback: ['google/gemini-2.5-flash', 'deepseek/deepseek-chat'],
+    },
+    COMPLEX: {
+        primary: 'google/gemini-3.1-pro',
+        fallback: ['anthropic/claude-sonnet-4.6', 'google/gemini-2.5-pro'],
+    },
+    REASONING: {
+        primary: 'xai/grok-4-1-fast-reasoning',
+        fallback: ['deepseek/deepseek-reasoner', 'openai/o4-mini'],
+    },
+};
+const ECO_TIERS = {
+    SIMPLE: {
+        primary: 'nvidia/gpt-oss-120b',
+        fallback: ['google/gemini-2.5-flash-lite'],
+    },
+    MEDIUM: {
+        primary: 'google/gemini-2.5-flash-lite',
+        fallback: ['nvidia/gpt-oss-120b'],
+    },
+    COMPLEX: {
+        primary: 'google/gemini-2.5-flash-lite',
+        fallback: ['deepseek/deepseek-chat'],
+    },
+    REASONING: {
+        primary: 'xai/grok-4-1-fast-reasoning',
+        fallback: ['deepseek/deepseek-reasoner'],
+    },
+};
+const PREMIUM_TIERS = {
+    SIMPLE: {
+        primary: 'moonshot/kimi-k2.5',
+        fallback: ['anthropic/claude-haiku-4.5'],
+    },
+    MEDIUM: {
+        primary: 'openai/gpt-5.3-codex',
+        fallback: ['anthropic/claude-sonnet-4.6'],
+    },
+    COMPLEX: {
+        primary: 'anthropic/claude-opus-4.6',
+        fallback: ['openai/gpt-5.4', 'anthropic/claude-sonnet-4.6'],
+    },
+    REASONING: {
+        primary: 'anthropic/claude-sonnet-4.6',
+        fallback: ['anthropic/claude-opus-4.6', 'openai/o3'],
+    },
+};
+// ─── Keywords for Classification ───
+const CODE_KEYWORDS = [
+    'function', 'class', 'import', 'def', 'SELECT', 'async', 'await',
+    'const', 'let', 'var', 'return', '```', '函数', '类', '导入',
+];
+const REASONING_KEYWORDS = [
+    'prove', 'theorem', 'derive', 'step by step', 'chain of thought',
+    'formally', 'mathematical', 'proof', 'logically', '证明', '定理', '推导',
+];
+const SIMPLE_KEYWORDS = [
+    'what is', 'define', 'translate', 'hello', 'yes or no', 'capital of',
+    'how old', 'who is', 'when was', '什么是', '翻译', '你好',
+];
+const TECHNICAL_KEYWORDS = [
+    'algorithm', 'optimize', 'architecture', 'distributed', 'kubernetes',
+    'microservice', 'database', 'infrastructure', '算法', '架构', '优化',
+];
+const AGENTIC_KEYWORDS = [
+    'read file', 'edit', 'modify', 'update', 'create file', 'execute',
+    'deploy', 'install', 'npm', 'pip', 'fix', 'debug', 'verify',
+    '编辑', '修改', '部署', '安装', '修复', '调试',
+];
+function countMatches(text, keywords) {
+    const lower = text.toLowerCase();
+    return keywords.filter(kw => lower.includes(kw.toLowerCase())).length;
+}
+function classifyRequest(prompt, tokenCount) {
+    const signals = [];
+    let score = 0;
+    // Token count scoring (reduced weight - don't penalize short prompts too much)
+    if (tokenCount < 30) {
+        score -= 0.15;
+        signals.push('short');
+    }
+    else if (tokenCount > 500) {
+        score += 0.2;
+        signals.push('long');
+    }
+    // Code detection (weight: 0.20) - increased weight
+    const codeMatches = countMatches(prompt, CODE_KEYWORDS);
+    if (codeMatches >= 2) {
+        score += 0.5;
+        signals.push('code');
+    }
+    else if (codeMatches >= 1) {
+        score += 0.25;
+        signals.push('code-light');
+    }
+    // Reasoning detection (weight: 0.18)
+    const reasoningMatches = countMatches(prompt, REASONING_KEYWORDS);
+    if (reasoningMatches >= 2) {
+        // Direct reasoning override
+        return { tier: 'REASONING', confidence: 0.9, signals: [...signals, 'reasoning'] };
+    }
+    else if (reasoningMatches >= 1) {
+        score += 0.4;
+        signals.push('reasoning-light');
+    }
+    // Simple detection (weight: -0.12) - only trigger on strong simple signals
+    const simpleMatches = countMatches(prompt, SIMPLE_KEYWORDS);
+    if (simpleMatches >= 2) {
+        score -= 0.4;
+        signals.push('simple');
+    }
+    else if (simpleMatches >= 1 && codeMatches === 0 && tokenCount < 50) {
+        // Only mark as simple if no code and very short
+        score -= 0.25;
+        signals.push('simple');
+    }
+    // Technical complexity (weight: 0.15) - increased
+    const techMatches = countMatches(prompt, TECHNICAL_KEYWORDS);
+    if (techMatches >= 2) {
+        score += 0.4;
+        signals.push('technical');
+    }
+    else if (techMatches >= 1) {
+        score += 0.2;
+        signals.push('technical-light');
+    }
+    // Agentic detection (weight: 0.10) - increased
+    const agenticMatches = countMatches(prompt, AGENTIC_KEYWORDS);
+    if (agenticMatches >= 3) {
+        score += 0.35;
+        signals.push('agentic');
+    }
+    else if (agenticMatches >= 2) {
+        score += 0.2;
+        signals.push('agentic-light');
+    }
+    // Multi-step patterns
+    if (/first.*then|step \d|\d\.\s/i.test(prompt)) {
+        score += 0.2;
+        signals.push('multi-step');
+    }
+    // Question complexity
+    const questionCount = (prompt.match(/\?/g) || []).length;
+    if (questionCount > 3) {
+        score += 0.15;
+        signals.push(`${questionCount} questions`);
+    }
+    // Imperative verbs (build, create, implement, etc.)
+    const imperativeMatches = countMatches(prompt, [
+        'build', 'create', 'implement', 'design', 'develop', 'write', 'make',
+        'generate', 'construct', '构建', '创建', '实现', '设计', '开发'
+    ]);
+    if (imperativeMatches >= 1) {
+        score += 0.15;
+        signals.push('imperative');
+    }
+    // Map score to tier (adjusted boundaries)
+    let tier;
+    if (score < -0.1) {
+        tier = 'SIMPLE';
+    }
+    else if (score < 0.25) {
+        tier = 'MEDIUM';
+    }
+    else if (score < 0.45) {
+        tier = 'COMPLEX';
+    }
+    else {
+        tier = 'REASONING';
+    }
+    // Calculate confidence based on distance from boundary
+    const confidence = Math.min(0.95, 0.7 + Math.abs(score) * 0.3);
+    return { tier, confidence, signals };
+}
+// ─── Main Router ───
+export function routeRequest(prompt, profile = 'auto') {
+    // Free profile - always use free model
+    if (profile === 'free') {
+        return {
+            model: 'nvidia/gpt-oss-120b',
+            tier: 'SIMPLE',
+            confidence: 1.0,
+            signals: ['free-profile'],
+            savings: 1.0,
+        };
+    }
+    // Estimate token count (rough: 4 chars per token)
+    const tokenCount = Math.ceil(prompt.length / 4);
+    // Classify the request
+    const { tier, confidence, signals } = classifyRequest(prompt, tokenCount);
+    // Select tier config based on profile
+    let tierConfigs;
+    switch (profile) {
+        case 'eco':
+            tierConfigs = ECO_TIERS;
+            break;
+        case 'premium':
+            tierConfigs = PREMIUM_TIERS;
+            break;
+        default:
+            tierConfigs = AUTO_TIERS;
+    }
+    const model = tierConfigs[tier].primary;
+    // Calculate savings estimate
+    // Baseline: Claude Opus at $5/$25 per 1M tokens
+    const OPUS_COST_PER_1K = 0.015; // rough average
+    const modelCosts = {
+        'nvidia/gpt-oss-120b': 0,
+        'google/gemini-2.5-flash': 0.001,
+        'google/gemini-2.5-flash-lite': 0.0003,
+        'deepseek/deepseek-chat': 0.0004,
+        'moonshot/kimi-k2.5': 0.002,
+        'google/gemini-3.1-pro': 0.007,
+        'anthropic/claude-sonnet-4.6': 0.009,
+        'anthropic/claude-opus-4.6': 0.015,
+        'xai/grok-4-1-fast-reasoning': 0.0004,
+    };
+    const modelCost = modelCosts[model] ?? 0.005;
+    const savings = Math.max(0, (OPUS_COST_PER_1K - modelCost) / OPUS_COST_PER_1K);
+    return {
+        model,
+        tier,
+        confidence,
+        signals,
+        savings,
+    };
+}
+/**
+ * Get fallback models for a tier
+ */
+export function getFallbackChain(tier, profile = 'auto') {
+    let tierConfigs;
+    switch (profile) {
+        case 'eco':
+            tierConfigs = ECO_TIERS;
+            break;
+        case 'premium':
+            tierConfigs = PREMIUM_TIERS;
+            break;
+        case 'free':
+            return ['nvidia/gpt-oss-120b'];
+        default:
+            tierConfigs = AUTO_TIERS;
+    }
+    const config = tierConfigs[tier];
+    return [config.primary, ...config.fallback];
+}
+/**
+ * Parse routing profile from model string
+ */
+export function parseRoutingProfile(model) {
+    const lower = model.toLowerCase();
+    if (lower === 'blockrun/auto' || lower === 'auto')
+        return 'auto';
+    if (lower === 'blockrun/eco' || lower === 'eco')
+        return 'eco';
+    if (lower === 'blockrun/premium' || lower === 'premium')
+        return 'premium';
+    if (lower === 'blockrun/free' || lower === 'free')
+        return 'free';
+    return null;
+}