freegate 0.6.13 → 0.6.15

package/lib/bandit.js

@@ -0,0 +1,79 @@
+// Thompson sampling (Beta-Bernoulli) bandit для выбора провайдера.
+// Каждый провайдер в каждом бакете сложности имеет приоры Beta(a, b).
+// Выбор: рисуем сэмпл из Beta(a, b) для каждого, берём максимум.
+// Исход: успех → a+=1, фейл → b+=1.
+
+const BUCKET_THRESHOLDS = [0.4, 0.7];
+
+function bucket(complexity) {
+  if (complexity < BUCKET_THRESHOLDS[0]) return 'low';
+  if (complexity < BUCKET_THRESHOLDS[1]) return 'med';
+  return 'high';
+}
+
+// Standard normal via polar method (Box-Muller).
+function stdNormal() {
+  let u1, u2, s;
+  do { u1 = Math.random() * 2 - 1; u2 = Math.random() * 2 - 1; s = u1 * u1 + u2 * u2; } while (s >= 1 || s === 0);
+  return u1 * Math.sqrt(-2 * Math.log(s) / s);
+}
+
+// Marsaglia-Tsang sampling of Gamma(shape, scale=1). Valid for shape >= 1.
+function sampleGamma(shape) {
+  if (shape < 1) {
+    return sampleGamma(shape + 1) * Math.pow(Math.random(), 1 / shape);
+  }
+  const d = shape - 1 / 3;
+  const c = 1 / Math.sqrt(9 * d);
+  for (;;) {
+    let x, v;
+    do { x = stdNormal(); } while (1 + c * x <= 0);
+    v = 1 + c * x;
+    v = v * v * v;
+    const u = Math.random();
+    if (u < 1 - 0.0331 * x * x * x * x) return d * v;
+    if (Math.log(u) < 0.5 * x * x + d * (1 - v + Math.log(v))) return d * v;
+  }
+}
+
+// Сэмпл из Beta(alpha, beta). Beta(1,1) = uniform.
+function sampleBeta(alpha, beta) {
+  if (alpha <= 0 || beta <= 0) return 0.5;
+  const x = sampleGamma(alpha);
+  const y = sampleGamma(beta);
+  const denom = x + y;
+  return denom > 0 ? x / denom : 0.5;
+}
+
+// Выбор провайдера. Сэмпл из Beta(prior) умножается на weight (safety-штрафы
+// типа ratelimited ×0.05 должны действовать и при холодном старте). Приоры
+// bandit'а доминируют по мере накопления исходов.
+function pick(scored, bucketPriors) {
+  let best = null;
+  let bestVal = -Infinity;
+  for (const item of scored) {
+    const key = item.key;
+    const weight = typeof item.weight === 'number' ? item.weight : 1;
+    const prior = (bucketPriors && bucketPriors[key]) || { a: 1, b: 1 };
+    const sample = sampleBeta(prior.a + 1, prior.b + 1);
+    const val = sample * weight;
+    if (val > bestVal) { bestVal = val; best = key; }
+  }
+  return best;
+}
+
+// Обновление приоров после исхода.
+function recordOutcome(bucketPriors, key, success) {
+  bucketPriors[key] = bucketPriors[key] || { a: 1, b: 1 };
+  if (success) bucketPriors[key].a += 1;
+  else bucketPriors[key].b += 1;
+}
+
+// Временные лимиты (429/403/402/401) — это НЕ качество провайдера, а временное
+// состояние (лимит запросов, квота, баланс). Bandit не должен наказывать за них.
+const TRANSIENT_LIMITS = new Set([401, 402, 403, 408, 429]);
+function isTransientLimit(status) {
+  return typeof status === 'number' && TRANSIENT_LIMITS.has(status);
+}
+
+module.exports = { bucket, sampleBeta, pick, recordOutcome, BUCKET_THRESHOLDS, isTransientLimit };

package/lib/health.js

@@ -7,7 +7,7 @@ const STATE_PATH = path.join(__dirname, '..', 'state.json');
 
 let health = {};
 let circuitBreakers = {};
-let stats = { totalRequests: 0, successfulRequests: 0, failedRequests: 0, providerUsage: {}, errors: {}, startTime: Date.now(), tokenUsage: {} };
+let stats = { totalRequests: 0, successfulRequests: 0, failedRequests: 0, providerUsage: {}, errors: {}, startTime: Date.now(), tokenUsage: {}, bandit: { low: {}, med: {}, high: {} } };
 let lastSelection = null;
 
 const MAX_RECENT = 50;
@@ -31,6 +31,7 @@ function loadState() {
       tokenUsage: saved.tokenUsage || {},
       dailyUsage: saved.dailyUsage || {},
       reliability: saved.reliability || {},
+      bandit: saved.bandit || { low: {}, med: {}, high: {} },
     };
     logger.info('State loaded', { healthKeys: Object.keys(health) });
   } catch {
@@ -176,6 +177,14 @@ function getRecent() { return recent; }
 function getRpm() { return rpm; }
 function getDailyUsage() { return stats.dailyUsage || {}; }
 
+function getBandit() { return stats.bandit; }
+function recordBandit(bucketName, key, success) {
+  stats.bandit[bucketName] = stats.bandit[bucketName] || {};
+  stats.bandit[bucketName][key] = stats.bandit[bucketName][key] || { a: 1, b: 1 };
+  if (success) stats.bandit[bucketName][key].a += 1;
+  else stats.bandit[bucketName][key].b += 1;
+}
+
 // Auto-save every 30 seconds
 const _saveTimer = setInterval(saveState, 30000);
 
@@ -188,5 +197,6 @@ module.exports = {
   recordRecent, recordRpm, getRecent, getRpm,
   getDailyUsage, getReliability,
   recordSelection, getLastSelection,
+  getBandit, recordBandit,
   _stopTimers,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freegate",
-  "version": "0.6.13",
+  "version": "0.6.15",
   "description": "Free multi-provider LLM gateway with automatic failover. One OpenAI-compatible endpoint routes to 25 free models (Groq, Mistral, Gemini, NIM, OpenRouter, ZAI, Cerebras, DeepSeek). Never pay for LLMs.",
   "license": "MIT",
   "bin": {

package/server.js

@@ -4,12 +4,13 @@ const fs = require('fs');
 const path = require('path');
 const { LRUCache } = require('./lib/cache');
 const { PROVIDERS, MODEL_MAP, callProvider } = require('./lib/providers');
-const { loadState, initHealth, isCircuitOpen, recordSuccess, recordFailure, recordRequest, recordTokens, getHealth, getStats, recordRecent, recordRpm, getRecent, getRpm, recordSelection, getLastSelection } = require('./lib/health');
+const { loadState, initHealth, isCircuitOpen, recordSuccess, recordFailure, recordRequest, recordTokens, getHealth, getStats, recordRecent, recordRpm, getRecent, getRpm, recordSelection, getLastSelection, getBandit, recordBandit } = require('./lib/health');
 const { checkRateLimit } = require('./lib/rateLimit');
 const { handleDashboard } = require('./lib/dashboard');
 const { acquire, stats: poolStats } = require('./lib/pool');
 const { stripThink, cleanDelta, cleanMessage, fixReasoningMessage, isTooShort, MIN_ANSWER_LEN } = require('./lib/clean');
 const { classifyComplexity, maybeUpgradeTier, classifyVisionComplexity } = require('./lib/routing');
+const { bucket, pick: banditPick, isTransientLimit } = require('./lib/bandit');
 const logger = require('./lib/logger');
 
 // Load persisted state
@@ -138,7 +139,9 @@ async function handleChatCompletion(req, res, body) {
   const requestedModel = body.model || 'tier-splus';
   // Умный роутинг: сложные задачи с лёгкого тира поднимаем на более мощный.
   // Классифицируем ПОСЛЕ того, как определён requestedModel, ДО выбора провайдера.
-  let effectiveModel = maybeUpgradeTier(requestedModel, classifyComplexity(body.messages));
+  const complexity = classifyComplexity(body.messages);
+  let complexityBucket = bucket(complexity);
+  let effectiveModel = maybeUpgradeTier(requestedModel, complexity);
   let targetProviderKey = MODEL_MAP[effectiveModel] || MODEL_MAP[requestedModel] || 'zai';
   const isStreaming = body.stream === true;
 
@@ -209,6 +212,8 @@ async function handleChatCompletion(req, res, body) {
         // Умный vision-роутинг: скриншот с кодом/ошибкой поднимает тир.
         const vc = classifyVisionComplexity(cleaned);
         if (vc > 0) effectiveModel = maybeUpgradeTier(effectiveModel, vc);
+        // Vision-текст может изменить сложность — пересчитываем бакет.
+        complexityBucket = bucket(classifyVisionComplexity(cleaned));
         // Пересчитываем target-провайдера — vision-апгрейд мог сменить тир.
         targetProviderKey = MODEL_MAP[effectiveModel] || MODEL_MAP[requestedModel] || 'zai';
         // Replace image content with the extracted text as context,
@@ -274,47 +279,29 @@ async function handleChatCompletion(req, res, body) {
     const scored = pool.map(([key, provider]) => {
       const h = getHealth()[key];
       let score = h.score || 50;
-      // Latency is only reliable after real requests; unmeasured/zero latency
-      // must NOT balloon a provider's weight. Treat <100ms as neutral.
       const rawLat = h.latency || 0;
       const lat = rawLat > 0 ? Math.max(rawLat, 100) : 500;
       let weight = score / lat;
-      // Rate-limited providers are last resort — heavy penalty
       if (h.status === 'ratelimited') weight *= 0.05;
-      // Mapped (target) provider gets a SLIGHT preference, but the pool must
-      // still be able to pick faster/healthier providers for tier aliases —
-      // otherwise Freegate always routes tier-s to Codestral and never varies.
       if (key === targetProviderKey) weight *= 1.15;
       const dailyLimit = provider.dailyLimit || 1000;
       const usedToday = getStats().providerUsage[key] || 0;
       if (usedToday >= dailyLimit * 0.9) weight *= 0.5;
-      // Providers with a history of failures lose weight (stability first).
-      // Use TODAY's failure count (reliability.fail) so overloaded providers
-      // are excluded now but recover next day. Heavy count → near-exclusion.
-      const relToday = getStats().reliability?.[key];
-      const todayFails = relToday?.day === today ? (relToday.fail || 0) : 0;
-      if (todayFails > 5) weight *= 0.4;
-      if (todayFails > 20) weight *= 0.05;
-      // Today's reliability: providers that have been 100% successful get a boost
-      const rel = getStats().reliability?.[key];
-      if (rel && rel.success + rel.fail >= 3) {
-        const ratio = rel.success / (rel.success + rel.fail);
-        if (ratio === 1) weight *= 1.3;
-        else if (ratio < 0.5) weight *= 0.5;
-      }
       return { key, provider, weight };
-    }).sort((a, b) => b.weight - a.weight);
-
-    const totalWeight = scored.reduce((s, p) => s + p.weight, 0);
-    // Weighted random: pick ONE provider as the starting candidate. The rest
-    // are kept as fallbacks below. (Bugfix: was assigning the whole `scored`
-    // list, which made the first (heaviest) provider win every time.)
-    let r = Math.random() * totalWeight;
-    for (const p of scored) {
-      r -= p.weight;
-      if (r <= 0) { selected = [p]; break; }
-    }
-    if (selected.length === 0) selected = [scored[0]];
+    });
+
+    // Bandit weight contract: bandit's pick() multiplies the Beta sample by
+    // `weight`, so safety-штрафы (ratelimited ×0.05, target ×1.15) действуют и
+    // при холодном старте. score/latency держит вес ~0.01-1.0; приоры bandit'а
+    // (a,b ~1+) со временем начинают доминировать. Не добавляй нормализацию
+    // здесь, пока измеренные веса не превысят ~5.
+    // Thompson sampling: рисуем сэмпл Beta(a+1, b+1) для каждого, умножаем на
+    // weight, выбираем максимум. Приоры из бакета сложности (bandit обучается).
+    const priors = getBandit()[complexityBucket] || {};
+    const bestKey = banditPick(scored, priors);
+    const bestProvider = scored.find((p) => p.key === bestKey);
+    if (bestProvider) selected = [bestProvider];
+    else if (scored.length > 0) selected = [scored[0]];
   }
 
   // Weighted-random picked ONE provider as the primary; append the rest of the
@@ -380,6 +367,7 @@ async function handleChatCompletion(req, res, body) {
           errors.push(msg);
           recordFailure(key, 0);
           recordRequest(key, false, msg);
+          recordBandit(complexityBucket, key, false);
           recordRecent({ model: requestedModel, provider: key, status: 204, latency: result.latency, cached: false });
           logger.warn('Empty or too-short response, trying next provider', { key });
           continue;
@@ -437,6 +425,8 @@ async function handleChatCompletion(req, res, body) {
           });
           result.stream.on('end', () => {
             const full = chunks.join('');
+            // Bandit учится по качеству: пустой/мусорный стрим = фейл.
+            recordBandit(complexityBucket, key, full.trim().length >= MIN_ANSWER_LEN);
             if (full.trim().length >= MIN_ANSWER_LEN) {
               cache.set(effectiveModel, body.messages, body.temperature, {
                 id: 'chatcmpl-cached',
@@ -449,7 +439,11 @@ async function handleChatCompletion(req, res, body) {
             }
             res.end();
           });
-          result.stream.on('error', (err) => { logger.error('Stream error', { key, error: err.message }); res.end(); });
+          result.stream.on('error', (err) => {
+            logger.error('Stream error', { key, error: err.message });
+            if (!isTransientLimit(err.statusCode)) recordBandit(complexityBucket, key, false);
+            res.end();
+          });
           result.stream.pipe(cleaner).pipe(res);
           return;
         }
@@ -486,6 +480,7 @@ async function handleChatCompletion(req, res, body) {
           errors.push(msg);
           recordFailure(key, 0);
           recordRequest(key, false, msg);
+          recordBandit(complexityBucket, key, false);
           recordRecent({ model: requestedModel, provider: key, status: 204, latency: result.latency, cached: false });
           logger.warn('Streaming fallback: no first token', { key });
           try { result.stream.destroy(); } catch {}
@@ -516,6 +511,8 @@ async function handleChatCompletion(req, res, body) {
         });
         result.stream.on('end', () => {
           const full = chunks.join('');
+          // Bandit учится по качеству: обрыв/мусорный стрим = фейл.
+          recordBandit(complexityBucket, key, full.trim().length >= MIN_ANSWER_LEN);
           if (full.trim().length >= MIN_ANSWER_LEN) {
             cache.set(effectiveModel, body.messages, body.temperature, {
               id: 'chatcmpl-cached',
@@ -530,6 +527,7 @@ async function handleChatCompletion(req, res, body) {
         });
         result.stream.on('error', (err) => {
           logger.error('Stream error', { key, error: err.message });
+          if (!isTransientLimit(err.statusCode)) recordBandit(complexityBucket, key, false);
           res.end();
         });
         return;
@@ -539,6 +537,7 @@ async function handleChatCompletion(req, res, body) {
         // content already verified non-empty above
         recordSuccess(key);
         recordRequest(key, true);
+        recordBandit(complexityBucket, key, true);
         logger.request({ model: requestedModel, provider: key, status: 200, latency: result.latency, stream: isStreaming });
         recordRecent({ model: requestedModel, provider: key, status: 200, latency: result.latency, cached: false });
         recordSelection(key, provider.model, requestedModel);
@@ -552,6 +551,8 @@ async function handleChatCompletion(req, res, body) {
       const statusCode = err.statusCode || 502;
       errors.push(err.message);
       recordRequest(key, false, err.message);
+      // Временные лимиты (429/403/402) — не наказываем провайдера в bandit.
+      if (!isTransientLimit(statusCode)) recordBandit(complexityBucket, key, false);
       recordRecent({ model: requestedModel, provider: key, status: statusCode, latency: 0, cached: false });
       initHealth(key);
       // Do NOT flip provider to 'error' on a single failed request — transient
@@ -603,11 +604,13 @@ async function handleChatCompletion(req, res, body) {
           if (isTooShort(result.data)) {
             recordFailure(key, 0);
             recordRequest(key, false, key + ': empty or too short response (retry)');
+            recordBandit(complexityBucket, key, false);
             logger.warn('Empty or too-short response in retry, trying next', { key });
             continue;
           }
           recordSuccess(key);
           recordRequest(key, true);
+          recordBandit(complexityBucket, key, true);
           recordRecent({ model: requestedModel, provider: key, status: 200, latency: result.latency, cached: false });
           recordSelection(key, provider.model, requestedModel);
           cache.set(effectiveModel, body.messages, body.temperature, result.data);
@@ -654,6 +657,8 @@ async function handleChatCompletion(req, res, body) {
           });
           result.stream.on('end', () => {
             const full = chunks.join('');
+            // Bandit учится по качеству в ретрае тоже.
+            recordBandit(complexityBucket, key, full.trim().length >= MIN_ANSWER_LEN);
             if (full.trim().length >= MIN_ANSWER_LEN) {
               cache.set(effectiveModel, body.messages, body.temperature, {
                 id: 'chatcmpl-cached',
@@ -668,12 +673,14 @@ async function handleChatCompletion(req, res, body) {
           });
           result.stream.on('error', (err) => {
             logger.error('Stream error (retry)', { key, error: err.message });
+            if (!isTransientLimit(err.statusCode)) recordBandit(complexityBucket, key, false);
             res.end();
           });
           return;
         }
       } catch (err2) {
         recordRequest(key, false, err2.message);
+        if (!isTransientLimit(err2.statusCode)) recordBandit(complexityBucket, key, false);
         recordFailure(key, err2.statusCode);
       }
     }
@@ -748,6 +755,7 @@ const server = http.createServer(async (req, res) => {
       limits,
       pool: poolStats(),
       last_selection: getLastSelection(),
+      bandit: getBandit(),
     }));
     return;
   }