@relayplane/proxy 1.5.1 → 1.5.2

package/dist/standalone-proxy.js

@@ -99,9 +99,33 @@ exports.DEFAULT_ENDPOINTS = {
         baseUrl: 'https://api.x.ai/v1',
         apiKeyEnv: 'XAI_API_KEY',
     },
-    moonshot: {
-        baseUrl: 'https://api.moonshot.cn/v1',
-        apiKeyEnv: 'MOONSHOT_API_KEY',
+    openrouter: {
+        baseUrl: 'https://openrouter.ai/api/v1',
+        apiKeyEnv: 'OPENROUTER_API_KEY',
+    },
+    deepseek: {
+        baseUrl: 'https://api.deepseek.com/v1',
+        apiKeyEnv: 'DEEPSEEK_API_KEY',
+    },
+    groq: {
+        baseUrl: 'https://api.groq.com/openai/v1',
+        apiKeyEnv: 'GROQ_API_KEY',
+    },
+    mistral: {
+        baseUrl: 'https://api.mistral.ai/v1',
+        apiKeyEnv: 'MISTRAL_API_KEY',
+    },
+    together: {
+        baseUrl: 'https://api.together.xyz/v1',
+        apiKeyEnv: 'TOGETHER_API_KEY',
+    },
+    fireworks: {
+        baseUrl: 'https://api.fireworks.ai/inference/v1',
+        apiKeyEnv: 'FIREWORKS_API_KEY',
+    },
+    perplexity: {
+        baseUrl: 'https://api.perplexity.ai',
+        apiKeyEnv: 'PERPLEXITY_API_KEY',
     },
 };
 /**
@@ -273,6 +297,127 @@ const globalStats = {
     escalations: 0,
     startedAt: Date.now(),
 };
+const requestHistory = [];
+const MAX_HISTORY = 10000;
+const HISTORY_RETENTION_DAYS = 7;
+let requestIdCounter = 0;
+// --- Persistent history (JSONL) ---
+const HISTORY_DIR = path.join(os.homedir(), '.relayplane');
+const HISTORY_FILE = path.join(HISTORY_DIR, 'history.jsonl');
+let historyWriteBuffer = [];
+let historyFlushTimer = null;
+let historyRequestsSinceLastPrune = 0;
+function pruneOldEntries() {
+    const cutoff = Date.now() - HISTORY_RETENTION_DAYS * 86400000;
+    // Remove old entries from in-memory array
+    while (requestHistory.length > 0 && new Date(requestHistory[0].timestamp).getTime() < cutoff) {
+        requestHistory.shift();
+    }
+    // Cap at MAX_HISTORY
+    while (requestHistory.length > MAX_HISTORY) {
+        requestHistory.shift();
+    }
+}
+function loadHistoryFromDisk() {
+    try {
+        if (!fs.existsSync(HISTORY_FILE))
+            return;
+        const content = fs.readFileSync(HISTORY_FILE, 'utf-8');
+        const cutoff = Date.now() - HISTORY_RETENTION_DAYS * 86400000;
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const entry = JSON.parse(trimmed);
+                if (new Date(entry.timestamp).getTime() >= cutoff) {
+                    requestHistory.push(entry);
+                }
+            }
+            catch {
+                // Skip corrupt lines
+            }
+        }
+        // Cap at MAX_HISTORY (keep most recent)
+        while (requestHistory.length > MAX_HISTORY) {
+            requestHistory.shift();
+        }
+        // Update requestIdCounter based on loaded entries
+        for (const entry of requestHistory) {
+            const match = entry.id.match(/^req-(\d+)$/);
+            if (match) {
+                const num = parseInt(match[1], 10);
+                if (num > requestIdCounter)
+                    requestIdCounter = num;
+            }
+        }
+        // Rewrite file with only valid/recent entries
+        rewriteHistoryFile();
+        console.log(`[RelayPlane] Loaded ${requestHistory.length} history entries from disk`);
+    }
+    catch (err) {
+        console.log(`[RelayPlane] Could not load history: ${err.message}`);
+    }
+}
+function rewriteHistoryFile() {
+    try {
+        fs.mkdirSync(HISTORY_DIR, { recursive: true });
+        const data = requestHistory.map(e => JSON.stringify(e)).join('\n') + (requestHistory.length ? '\n' : '');
+        fs.writeFileSync(HISTORY_FILE, data, 'utf-8');
+    }
+    catch (err) {
+        console.log(`[RelayPlane] Could not rewrite history file: ${err.message}`);
+    }
+}
+function flushHistoryBuffer() {
+    if (historyWriteBuffer.length === 0)
+        return;
+    try {
+        fs.mkdirSync(HISTORY_DIR, { recursive: true });
+        const data = historyWriteBuffer.map(e => JSON.stringify(e)).join('\n') + '\n';
+        fs.appendFileSync(HISTORY_FILE, data, 'utf-8');
+    }
+    catch (err) {
+        console.log(`[RelayPlane] Could not flush history: ${err.message}`);
+    }
+    historyWriteBuffer = [];
+}
+function scheduleHistoryFlush() {
+    if (historyFlushTimer)
+        return;
+    historyFlushTimer = setTimeout(() => {
+        historyFlushTimer = null;
+        flushHistoryBuffer();
+    }, 10000);
+}
+function bufferHistoryEntry(entry) {
+    historyWriteBuffer.push(entry);
+    historyRequestsSinceLastPrune++;
+    if (historyWriteBuffer.length >= 20) {
+        if (historyFlushTimer) {
+            clearTimeout(historyFlushTimer);
+            historyFlushTimer = null;
+        }
+        flushHistoryBuffer();
+    }
+    else {
+        scheduleHistoryFlush();
+    }
+    // Prune every 100 requests
+    if (historyRequestsSinceLastPrune >= 100) {
+        historyRequestsSinceLastPrune = 0;
+        pruneOldEntries();
+        rewriteHistoryFile();
+    }
+}
+function shutdownHistory() {
+    if (historyFlushTimer) {
+        clearTimeout(historyFlushTimer);
+        historyFlushTimer = null;
+    }
+    flushHistoryBuffer();
+}
 function logRequest(originalModel, targetModel, provider, latencyMs, success, mode, escalated) {
     const timestamp = new Date().toISOString();
     const status = success ? '✓' : '✗';
@@ -300,6 +445,35 @@ function logRequest(originalModel, targetModel, provider, latencyMs, success, mo
         viaProxy: true,
         success,
     });
+    // Record to request history for telemetry endpoints
+    const entry = {
+        id: `req-${++requestIdCounter}`,
+        originalModel,
+        targetModel,
+        provider,
+        latencyMs,
+        success,
+        mode,
+        escalated: !!escalated,
+        timestamp,
+        tokensIn: 0,
+        tokensOut: 0,
+        costUsd: 0,
+    };
+    requestHistory.push(entry);
+    if (requestHistory.length > MAX_HISTORY) {
+        requestHistory.shift();
+    }
+    bufferHistoryEntry(entry);
+}
+/** Update the most recent history entry with token/cost info */
+function updateLastHistoryEntry(tokensIn, tokensOut, costUsd) {
+    if (requestHistory.length > 0) {
+        const last = requestHistory[requestHistory.length - 1];
+        last.tokensIn = tokensIn;
+        last.tokensOut = tokensOut;
+        last.costUsd = costUsd;
+    }
 }
 const DEFAULT_PROXY_CONFIG = {
     enabled: true,
@@ -833,40 +1007,40 @@ async function forwardToXAIStream(request, targetModel, apiKey) {
     return response;
 }
 /**
- * Forward non-streaming request to Moonshot API (OpenAI-compatible)
+ * Forward non-streaming request to OpenAI-compatible provider (OpenRouter, DeepSeek, Groq)
  */
-async function forwardToMoonshot(request, targetModel, apiKey) {
-    const moonshotBody = {
+async function forwardToOpenAICompatible(request, targetModel, apiKey, provider = 'openrouter') {
+    const compatBody = {
         ...request,
         model: targetModel,
         stream: false,
     };
-    const response = await fetch('https://api.moonshot.cn/v1/chat/completions', {
+    const response = await fetch(`${exports.DEFAULT_ENDPOINTS[provider]?.baseUrl || "https://openrouter.ai/api/v1"}/chat/completions`, {
         method: 'POST',
         headers: {
             'Content-Type': 'application/json',
             Authorization: `Bearer ${apiKey}`,
         },
-        body: JSON.stringify(moonshotBody),
+        body: JSON.stringify(compatBody),
     });
     return response;
 }
 /**
- * Forward streaming request to Moonshot API (OpenAI-compatible)
+ * Forward streaming request to OpenAI-compatible provider (OpenRouter, DeepSeek, Groq)
  */
-async function forwardToMoonshotStream(request, targetModel, apiKey) {
-    const moonshotBody = {
+async function forwardToOpenAICompatibleStream(request, targetModel, apiKey, provider = 'openrouter') {
+    const compatBody = {
         ...request,
         model: targetModel,
         stream: true,
     };
-    const response = await fetch('https://api.moonshot.cn/v1/chat/completions', {
+    const response = await fetch(`${exports.DEFAULT_ENDPOINTS[provider]?.baseUrl || "https://openrouter.ai/api/v1"}/chat/completions`, {
         method: 'POST',
         headers: {
             'Content-Type': 'application/json',
             Authorization: `Bearer ${apiKey}`,
         },
-        body: JSON.stringify(moonshotBody),
+        body: JSON.stringify(compatBody),
     });
     return response;
 }
@@ -1346,7 +1520,7 @@ function parsePreferredModel(preferredModel) {
     if (!provider || !model)
         return null;
     // Validate provider
-    const validProviders = ['openai', 'anthropic', 'google', 'xai', 'moonshot', 'local'];
+    const validProviders = ['openai', 'anthropic', 'google', 'xai', 'openrouter', 'deepseek', 'groq', 'local'];
     if (!validProviders.includes(provider))
         return null;
     return { provider: provider, model };
@@ -1393,14 +1567,14 @@ function resolveExplicitModel(modelName) {
     if (modelName.startsWith('grok-')) {
         return { provider: 'xai', model: modelName };
     }
-    // Moonshot models (moonshot-*)
-    if (modelName.startsWith('moonshot-')) {
-        return { provider: 'moonshot', model: modelName };
+    // OpenRouter/DeepSeek/Groq models
+    if (modelName.startsWith('openrouter/') || modelName.startsWith('deepseek-') || modelName.startsWith('groq-')) {
+        return { provider: 'openrouter', model: modelName };
     }
     // Provider-prefixed format: "anthropic/claude-3-5-sonnet-latest"
     if (modelName.includes('/')) {
         const [provider, model] = modelName.split('/');
-        const validProviders = ['openai', 'anthropic', 'google', 'xai', 'moonshot', 'local'];
+        const validProviders = ['openai', 'anthropic', 'google', 'xai', 'openrouter', 'deepseek', 'groq', 'local'];
         if (provider && model && validProviders.includes(provider)) {
             return { provider: provider, model };
         }
@@ -1581,6 +1755,73 @@ async function cascadeRequest(config, makeRequest, log) {
     }
     throw new Error('All cascade models exhausted');
 }
+function getDashboardHTML() {
+    return `<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>RelayPlane Dashboard</title>
+<style>
+*{margin:0;padding:0;box-sizing:border-box}body{background:#0a0b0d;color:#e2e8f0;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif;padding:20px;max-width:1200px;margin:0 auto}
+a{color:#34d399}h1{font-size:1.5rem;font-weight:600}
+.header{display:flex;justify-content:space-between;align-items:center;padding:16px 0;border-bottom:1px solid #1e293b;margin-bottom:24px}
+.header .meta{font-size:.8rem;color:#64748b}
+.cards{display:grid;grid-template-columns:repeat(auto-fit,minmax(200px,1fr));gap:16px;margin-bottom:32px}
+.card{background:#111318;border:1px solid #1e293b;border-radius:12px;padding:20px}
+.card .label{font-size:.75rem;color:#64748b;text-transform:uppercase;letter-spacing:.05em;margin-bottom:6px}
+.card .value{font-size:1.75rem;font-weight:700}.green{color:#34d399}
+table{width:100%;border-collapse:collapse;font-size:.85rem}
+th{text-align:left;color:#64748b;font-weight:500;padding:8px 12px;border-bottom:1px solid #1e293b;font-size:.75rem;text-transform:uppercase;letter-spacing:.04em}
+td{padding:8px 12px;border-bottom:1px solid #111318}
+.section{margin-bottom:32px}.section h2{font-size:1rem;font-weight:600;margin-bottom:12px;color:#94a3b8}
+.dot{display:inline-block;width:8px;height:8px;border-radius:50%;margin-right:6px}.dot.up{background:#34d399}.dot.down{background:#ef4444}
+.badge{display:inline-block;padding:2px 8px;border-radius:6px;font-size:.75rem;font-weight:500}
+.badge.ok{background:#052e1633;color:#34d399}.badge.err{background:#2d0a0a;color:#ef4444}
+.prov{display:flex;gap:16px;flex-wrap:wrap}.prov-item{display:flex;align-items:center;font-size:.85rem;background:#111318;padding:8px 14px;border-radius:8px;border:1px solid #1e293b}
+</style></head><body>
+<div class="header"><div><h1>⚡ RelayPlane Dashboard</h1></div><div class="meta"><span id="ver"></span> · up <span id="uptime"></span> · refreshes every 5s</div></div>
+<div class="cards">
+  <div class="card"><div class="label">Total Requests</div><div class="value" id="totalReq">—</div></div>
+  <div class="card"><div class="label">Total Cost</div><div class="value" id="totalCost">—</div></div>
+  <div class="card"><div class="label">Savings</div><div class="value green" id="savings">—</div></div>
+  <div class="card"><div class="label">Avg Latency</div><div class="value" id="avgLat">—</div></div>
+</div>
+<div class="section"><h2>Model Breakdown</h2>
+<table><thead><tr><th>Model</th><th>Requests</th><th>Cost</th><th>% of Total</th></tr></thead><tbody id="models"></tbody></table></div>
+<div class="section"><h2>Provider Status</h2><div class="prov" id="providers"></div></div>
+<div class="section"><h2>Recent Runs</h2>
+<table><thead><tr><th>Time</th><th>Model</th><th>Tokens In</th><th>Tokens Out</th><th>Cost</th><th>Latency</th><th>Status</th></tr></thead><tbody id="runs"></tbody></table></div>
+<script>
+const $ = id => document.getElementById(id);
+function fmt(n,d=2){return typeof n==='number'?n.toFixed(d):'-'}
+function fmtTime(s){const d=new Date(s);return d.toLocaleTimeString()}
+function dur(s){const h=Math.floor(s/3600),m=Math.floor(s%3600/60);return h?h+'h '+m+'m':m+'m'}
+async function load(){
+  try{
+    const [health,stats,runsR,sav,provH]=await Promise.all([
+      fetch('/health').then(r=>r.json()),
+      fetch('/v1/telemetry/stats').then(r=>r.json()),
+      fetch('/v1/telemetry/runs?limit=20').then(r=>r.json()),
+      fetch('/v1/telemetry/savings').then(r=>r.json()),
+      fetch('/v1/telemetry/health').then(r=>r.json())
+    ]);
+    $('ver').textContent='v'+health.version;
+    $('uptime').textContent=dur(health.uptime);
+    $('totalReq').textContent=health.requests??0;
+    $('totalCost').textContent='$'+fmt(stats.summary?.totalCostUsd??0,4);
+    $('savings').textContent=(sav.percentage??0)+'%';
+    $('avgLat').textContent=(stats.summary?.avgLatencyMs??0)+'ms';
+    const total=stats.summary?.totalEvents||1;
+    $('models').innerHTML=(stats.byModel||[]).map(m=>
+      '<tr><td>'+m.model+'</td><td>'+m.count+'</td><td>$'+fmt(m.costUsd,4)+'</td><td>'+fmt(m.count/total*100,1)+'%</td></tr>'
+    ).join('')||'<tr><td colspan=4 style="color:#64748b">No data yet</td></tr>';
+    $('runs').innerHTML=(runsR.runs||[]).map(r=>
+      '<tr><td>'+fmtTime(r.started_at)+'</td><td>'+r.model+'</td><td>'+(r.tokensIn||0)+'</td><td>'+(r.tokensOut||0)+'</td><td>$'+fmt(r.costUsd,4)+'</td><td>'+r.latencyMs+'ms</td><td><span class="badge '+(r.status==='success'?'ok':'err')+'">'+r.status+'</span></td></tr>'
+    ).join('')||'<tr><td colspan=7 style="color:#64748b">No runs yet</td></tr>';
+    $('providers').innerHTML=(provH.providers||[]).map(p=>
+      '<div class="prov-item"><span class="dot '+(p.status==='healthy'?'up':'down')+'"></span>'+p.provider+'</div>'
+    ).join('');
+  }catch(e){console.error(e)}
+}
+load();setInterval(load,5000);
+</script></body></html>`;
+}
 /**
  * Start the RelayPlane proxy server
  */
@@ -1593,6 +1834,15 @@ async function startProxy(config = {}) {
         if (verbose)
             console.log(`[relayplane] ${msg}`);
     };
+    // Load persistent history from disk
+    loadHistoryFromDisk();
+    // Flush history on shutdown
+    const handleShutdown = () => {
+        shutdownHistory();
+        process.exit(0);
+    };
+    process.on('SIGINT', handleShutdown);
+    process.on('SIGTERM', handleShutdown);
     const configPath = getProxyConfigPath();
     let proxyConfig = await loadProxyConfig(configPath, log);
     const cooldownManager = new CooldownManager(getCooldownConfig(proxyConfig));
@@ -1732,6 +1982,120 @@ async function startProxy(config = {}) {
                 return;
             }
         }
+        // === Telemetry endpoints for dashboard ===
+        if (pathname.startsWith('/v1/telemetry/')) {
+            const telemetryPath = pathname.replace('/v1/telemetry/', '');
+            const queryString = url.includes('?') ? url.split('?')[1] ?? '' : '';
+            const params = new URLSearchParams(queryString);
+            if (req.method === 'GET' && telemetryPath === 'stats') {
+                const days = parseInt(params.get('days') || '7', 10);
+                const cutoff = Date.now() - days * 86400000;
+                const recent = requestHistory.filter(r => new Date(r.timestamp).getTime() >= cutoff);
+                // Model breakdown
+                const modelMap = new Map();
+                for (const r of recent) {
+                    const key = r.targetModel;
+                    const cur = modelMap.get(key) || { count: 0, cost: 0 };
+                    cur.count++;
+                    cur.cost += r.costUsd;
+                    modelMap.set(key, cur);
+                }
+                // Daily stats
+                const dailyMap = new Map();
+                for (const r of recent) {
+                    const date = r.timestamp.slice(0, 10);
+                    const cur = dailyMap.get(date) || { requests: 0, cost: 0 };
+                    cur.requests++;
+                    cur.cost += r.costUsd;
+                    dailyMap.set(date, cur);
+                }
+                const totalCost = recent.reduce((s, r) => s + r.costUsd, 0);
+                const totalLatency = recent.reduce((s, r) => s + r.latencyMs, 0);
+                const result = {
+                    summary: {
+                        totalCostUsd: totalCost,
+                        totalEvents: recent.length,
+                        avgLatencyMs: recent.length ? Math.round(totalLatency / recent.length) : 0,
+                        successRate: recent.length ? recent.filter(r => r.success).length / recent.length : 0,
+                    },
+                    byModel: Array.from(modelMap.entries()).map(([model, v]) => ({ model, count: v.count, costUsd: v.cost, savings: 0 })),
+                    dailyCosts: Array.from(dailyMap.entries()).map(([date, v]) => ({ date, costUsd: v.cost, requests: v.requests })),
+                };
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(result));
+                return;
+            }
+            if (req.method === 'GET' && telemetryPath === 'runs') {
+                const limit = parseInt(params.get('limit') || '50', 10);
+                const offset = parseInt(params.get('offset') || '0', 10);
+                const sorted = [...requestHistory].reverse();
+                const runs = sorted.slice(offset, offset + limit).map(r => ({
+                    id: r.id,
+                    workflow_name: r.mode,
+                    status: r.success ? 'success' : 'error',
+                    started_at: r.timestamp,
+                    model: r.targetModel,
+                    routed_to: `${r.provider}/${r.targetModel}`,
+                    taskType: r.mode,
+                    costUsd: r.costUsd,
+                    latencyMs: r.latencyMs,
+                    tokensIn: r.tokensIn,
+                    tokensOut: r.tokensOut,
+                    savings: 0,
+                    original_model: r.originalModel,
+                }));
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ runs, pagination: { total: requestHistory.length } }));
+                return;
+            }
+            if (req.method === 'GET' && telemetryPath === 'savings') {
+                // Calculate savings: difference between cost if all requests used opus vs actual cost
+                const opusCostPer1kIn = 0.015;
+                const opusCostPer1kOut = 0.075;
+                let potentialCost = 0;
+                let actualCost = 0;
+                for (const r of requestHistory) {
+                    potentialCost += (r.tokensIn / 1000) * opusCostPer1kIn + (r.tokensOut / 1000) * opusCostPer1kOut;
+                    actualCost += r.costUsd;
+                }
+                const saved = potentialCost - actualCost;
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    total: potentialCost,
+                    savings: Math.max(0, saved),
+                    savedAmount: Math.max(0, saved),
+                    potentialSavings: potentialCost,
+                    percentage: potentialCost > 0 ? Math.round((saved / potentialCost) * 100) : 0,
+                    byDay: [],
+                }));
+                return;
+            }
+            if (req.method === 'GET' && telemetryPath === 'health') {
+                const providers = [];
+                for (const [name, ep] of Object.entries(exports.DEFAULT_ENDPOINTS)) {
+                    const hasKey = !!process.env[ep.apiKeyEnv];
+                    providers.push({
+                        provider: name,
+                        status: hasKey ? 'healthy' : 'down',
+                        latency: 0,
+                        successRate: hasKey ? 1 : 0,
+                        lastChecked: new Date().toISOString(),
+                    });
+                }
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ providers }));
+                return;
+            }
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Not found' }));
+            return;
+        }
+        // === Dashboard ===
+        if (req.method === 'GET' && (pathname === '/' || pathname === '/dashboard')) {
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end(getDashboardHTML());
+            return;
+        }
         // Extract auth context from incoming request
         const ctx = extractRequestContext(req);
         const anthropicEnvKey = process.env['ANTHROPIC_API_KEY'];
@@ -2405,6 +2769,13 @@ async function startProxy(config = {}) {
                     }, log);
                     const durationMs = Date.now() - startTime;
                     let responseData = cascadeResult.responseData;
+                    // Log cascade request for stats tracking
+                    logRequest(originalRequestedModel ?? 'unknown', cascadeResult.model, cascadeResult.provider, durationMs, true, 'cascade', cascadeResult.escalations > 0);
+                    const cascadeUsage = responseData?.usage;
+                    const cascadeTokensIn = cascadeUsage?.input_tokens ?? cascadeUsage?.prompt_tokens ?? 0;
+                    const cascadeTokensOut = cascadeUsage?.output_tokens ?? cascadeUsage?.completion_tokens ?? 0;
+                    const cascadeCost = (0, telemetry_js_1.estimateCost)(cascadeResult.model, cascadeTokensIn, cascadeTokensOut);
+                    updateLastHistoryEntry(cascadeTokensIn, cascadeTokensOut, cascadeCost);
                     if (recordTelemetry) {
                         try {
                             const runResult = await relay.run({
@@ -2426,15 +2797,14 @@ async function startProxy(config = {}) {
                         catch (err) {
                             log(`Failed to record run: ${err}`);
                         }
-                        const usage = responseData?.usage;
-                        const tokensIn = usage?.input_tokens ?? usage?.prompt_tokens ?? 0;
-                        const tokensOut = usage?.output_tokens ?? usage?.completion_tokens ?? 0;
-                        sendCloudTelemetry(taskType, cascadeResult.model, tokensIn, tokensOut, durationMs, true, undefined, originalRequestedModel ?? undefined);
+                        sendCloudTelemetry(taskType, cascadeResult.model, cascadeTokensIn, cascadeTokensOut, durationMs, true, undefined, originalRequestedModel ?? undefined);
                     }
                     res.writeHead(200, { 'Content-Type': 'application/json' });
                     res.end(JSON.stringify(responseData));
                 }
                 catch (err) {
+                    const durationMs = Date.now() - startTime;
+                    logRequest(originalRequestedModel ?? 'unknown', targetModel || 'unknown', targetProvider, durationMs, false, 'cascade');
                     if (err instanceof ProviderResponseError) {
                         res.writeHead(err.status, { 'Content-Type': 'application/json' });
                         res.end(JSON.stringify(err.payload));
@@ -2499,8 +2869,10 @@ async function executeNonStreamingProviderRequest(request, targetProvider, targe
             }
             break;
         }
-        case 'moonshot': {
-            providerResponse = await forwardToMoonshot(request, targetModel, apiKey);
+        case 'openrouter':
+        case 'deepseek':
+        case 'groq': {
+            providerResponse = await forwardToOpenAICompatible(request, targetModel, apiKey);
             responseData = (await providerResponse.json());
             if (!providerResponse.ok) {
                 return { responseData, ok: false, status: providerResponse.status };
@@ -2531,8 +2903,10 @@ async function handleStreamingRequest(res, request, targetProvider, targetModel,
             case 'xai':
                 providerResponse = await forwardToXAIStream(request, targetModel, apiKey);
                 break;
-            case 'moonshot':
-                providerResponse = await forwardToMoonshotStream(request, targetModel, apiKey);
+            case 'openrouter':
+            case 'deepseek':
+            case 'groq':
+                providerResponse = await forwardToOpenAICompatibleStream(request, targetModel, apiKey);
                 break;
             default:
                 providerResponse = await forwardToOpenAIStream(request, targetModel, apiKey);
@@ -2542,6 +2916,8 @@ async function handleStreamingRequest(res, request, targetProvider, targetModel,
             if (cooldownsEnabled) {
                 cooldownManager.recordFailure(targetProvider, JSON.stringify(errorData));
             }
+            const durationMs = Date.now() - startTime;
+            logRequest(request.model ?? 'unknown', targetModel, targetProvider, durationMs, false, routingMode);
             res.writeHead(providerResponse.status, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify(errorData));
             return;
@@ -2552,6 +2928,8 @@ async function handleStreamingRequest(res, request, targetProvider, targetModel,
         if (cooldownsEnabled) {
             cooldownManager.recordFailure(targetProvider, errorMsg);
         }
+        const durationMs = Date.now() - startTime;
+        logRequest(request.model ?? 'unknown', targetModel, targetProvider, durationMs, false, routingMode);
         res.writeHead(500, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ error: `Provider error: ${errorMsg}` }));
         return;
@@ -2608,7 +2986,7 @@ async function handleStreamingRequest(res, request, targetProvider, targetModel,
                 }
                 break;
             default:
-                // xAI, Moonshot, OpenAI all use OpenAI-compatible streaming format
+                // xAI, OpenRouter, DeepSeek, Groq, OpenAI all use OpenAI-compatible streaming format
                 for await (const chunk of pipeOpenAIStream(providerResponse)) {
                     res.write(chunk);
                     try {
@@ -2634,6 +3012,11 @@ async function handleStreamingRequest(res, request, targetProvider, targetModel,
         cooldownManager.recordSuccess(targetProvider);
     }
     const durationMs = Date.now() - startTime;
+    // Always log the request for stats/telemetry tracking
+    logRequest(request.model ?? 'unknown', targetModel, targetProvider, durationMs, true, routingMode);
+    // Update token/cost info on the history entry
+    const streamCost = (0, telemetry_js_1.estimateCost)(targetModel, streamTokensIn, streamTokensOut);
+    updateLastHistoryEntry(streamTokensIn, streamTokensOut, streamCost);
     if (recordTelemetry) {
         // Record the run (non-blocking)
         relay
@@ -2664,6 +3047,8 @@ async function handleNonStreamingRequest(res, request, targetProvider, targetMod
             if (cooldownsEnabled) {
                 cooldownManager.recordFailure(targetProvider, JSON.stringify(responseData));
             }
+            const durationMs = Date.now() - startTime;
+            logRequest(request.model ?? 'unknown', targetModel, targetProvider, durationMs, false, routingMode);
             res.writeHead(result.status, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify(responseData));
             return;
@@ -2674,6 +3059,8 @@ async function handleNonStreamingRequest(res, request, targetProvider, targetMod
         if (cooldownsEnabled) {
             cooldownManager.recordFailure(targetProvider, errorMsg);
         }
+        const durationMs = Date.now() - startTime;
+        logRequest(request.model ?? 'unknown', targetModel, targetProvider, durationMs, false, routingMode);
         res.writeHead(500, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ error: `Provider error: ${errorMsg}` }));
         return;
@@ -2682,6 +3069,14 @@ async function handleNonStreamingRequest(res, request, targetProvider, targetMod
         cooldownManager.recordSuccess(targetProvider);
     }
     const durationMs = Date.now() - startTime;
+    // Log the successful request
+    logRequest(request.model ?? 'unknown', targetModel, targetProvider, durationMs, true, routingMode);
+    // Update token/cost info
+    const usage = responseData?.usage;
+    const tokensIn = usage?.input_tokens ?? usage?.prompt_tokens ?? 0;
+    const tokensOut = usage?.output_tokens ?? usage?.completion_tokens ?? 0;
+    const cost = (0, telemetry_js_1.estimateCost)(targetModel, tokensIn, tokensOut);
+    updateLastHistoryEntry(tokensIn, tokensOut, cost);
     if (recordTelemetry) {
         // Record the run in RelayPlane
         try {