freegate 0.6.15 → 0.6.17

package/server.js

@@ -3,18 +3,26 @@ const http = require('http');
 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, getBandit, recordBandit } = require('./lib/health');
+const { PROVIDERS, MODEL_MAP, callProvider, reloadProviders } = require('./lib/providers');
+const { loadState, initHealth, isCircuitOpen, recordSuccess, recordFailure, recordRequest, recordTokens, getHealth, getStats, getReliability, recordRecent, recordRpm, getRecent, getRpm, recordSelection, getLastSelection, getBandit, recordBandit, warmBanditPriors, getContextStats } = require('./lib/health');
 const { checkRateLimit } = require('./lib/rateLimit');
 const { handleDashboard } = require('./lib/dashboard');
 const { acquire, stats: poolStats } = require('./lib/pool');
+const { aggregateSavings } = require('./lib/economics');
 const { stripThink, cleanDelta, cleanMessage, fixReasoningMessage, isTooShort, MIN_ANSWER_LEN } = require('./lib/clean');
-const { classifyComplexity, maybeUpgradeTier, classifyVisionComplexity } = require('./lib/routing');
+const { classifyComplexity, maybeUpgradeTier, classifyVisionComplexity, needsWindowUpgrade } = require('./lib/routing');
 const { bucket, pick: banditPick, isTransientLimit } = require('./lib/bandit');
+const { StringDecoder } = require('string_decoder');
 const logger = require('./lib/logger');
+const { KEY_GROUPS, readKeys, saveKeys, validateKey, getStoredKey } = require('./lib/setup');
+const { prepareMessages, estimateTokens, setMemory: compactorSetMemory } = require('./lib/compactor');
+const { classify: classifyTask } = require('./lib/taskclassify');
+const { injectMethodology, enabledByDefault: methodEnabledByDefault } = require('./lib/methodology');
+const { create: createMemoryStore } = require('./lib/memory-store');
 
 // Load persisted state
 loadState();
+const contextStats = getContextStats();
 
 // Drop stale health entries for providers that no longer exist (e.g. auto-disabled)
 const activeKeys = new Set(Object.keys(PROVIDERS));
@@ -26,6 +34,14 @@ if (stale.length > 0) {
   logger.info('Cleaned stale health entries', { removed: stale });
 }
 
+// Warm bandit priors for enabled providers with no/low history so brand-new
+// models (e.g. or-minimax-m3-free) are explored promptly instead of ignored.
+const warmed = warmBanditPriors(
+  Object.keys(PROVIDERS).filter(k => PROVIDERS[k].enabled !== false),
+  ['low', 'med', 'high']
+);
+if (warmed > 0) logger.info('Warmed bandit priors', { warmed });
+
 const cache = new LRUCache(500, 3600000, false, true); // 4th arg: semantic normalize ON
 require('./lib/cache')._activeCache = cache;
 
@@ -33,7 +49,7 @@ require('./lib/cache')._activeCache = cache;
 // Prefer cwd config.json (user's project) over the package dir.
 const CONFIG_CANDIDATES = [path.join(process.cwd(), 'config.json'), path.join(__dirname, 'config.json')];
 const CONFIG_PATH = CONFIG_CANDIDATES.find(p => fs.existsSync(p)) || CONFIG_CANDIDATES[1];
-let config = { port: 4000, auth: '', rateLimit: { maxRequests: 100, windowMs: 60000 } };
+let config = { port: 4000, auth: '', rateLimit: { maxRequests: 100, windowMs: 60000 }, methodology: true };
 try {
   const parsed = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
   if (parsed && typeof parsed === 'object') config = { ...config, ...parsed };
@@ -51,6 +67,75 @@ const PORT = parseInt(process.env.PORT || getArg('port', config.port || '4000'))
 const AUTH_KEY = process.env.AUTH || getArg('auth', config.auth || '');
 const RATE_LIMIT = config.rateLimit || { maxRequests: 100, windowMs: 60000 };
 
+// --- Долговременная память (vector memory) ---
+// По умолчанию включена: факты берутся побочно от компакции (без лишних вызовов
+// LLM) и подмешиваются в контекст по релевантности. config.memory.enabled=false —
+// слой отключается целиком.
+const MEMORY_CONFIG = Object.assign(
+  { enabled: true, topK: 3, minSimilarity: 0.05, coverageForSkip: 0.6 },
+  (config.memory && typeof config.memory === 'object') ? config.memory : {}
+);
+const memStore = MEMORY_CONFIG.enabled ? createMemoryStore({ filePath: path.join(__dirname, 'memory.json') }) : null;
+if (memStore) compactorSetMemory(memStore);
+
+// --- Семантический кэш ---
+// На промахе точного ключа ищет закэшированный диалог с похожим нормализованным
+// текстом (Dice по символьным триграммам). config.semcache.enabled=false отключает.
+const SEMCACHE_CONFIG = Object.assign(
+  { enabled: true, minSimilarity: 0.85 },
+  (config.semcache && typeof config.semcache === 'object') ? config.semcache : {}
+);
+
+// --- Методолог (инженерная дисциплина в промпте) ---
+// config.methodology.enabled=false отключает. По умолчанию включён.
+// config.methodology.prompts.{category} переопределяет текст промпта для
+// конкретной категории (незаданные категории остаются в дефолтах).
+const METHODOLOGY_CONFIG = Object.assign(
+  { enabled: methodEnabledByDefault(), prompts: {} },
+  (config.methodology && typeof config.methodology === 'object') ? config.methodology : {}
+);
+
+// --- Самообновляющаяся база моделей (Model Discovery Engine) ---
+// Планировщик живёт внутри сервера: работает «всегда» у всех пользователей
+// пакета без cron/launchd. config.modelManager.enabled=false отключает.
+function _loadEnvFile() {
+  try {
+    const envPath = path.join(__dirname, '.env');
+    if (!fs.existsSync(envPath)) return;
+    for (const line of fs.readFileSync(envPath, 'utf8').split('\n')) {
+      const t = line.trim();
+      if (!t || t.startsWith('#')) continue;
+      const eq = t.indexOf('=');
+      if (eq > 0 && !process.env[t.slice(0, eq).trim()]) process.env[t.slice(0, eq).trim()] = t.slice(eq + 1).trim();
+    }
+  } catch {}
+}
+_loadEnvFile();
+const { ModelManager } = require('./lib/modelmanager');
+const MODEL_MANAGER_CONFIG = Object.assign(
+  {},
+  (config.modelManager && typeof config.modelManager === 'object') ? config.modelManager : {}
+);
+const modelManager = new ModelManager({
+  dbPath: path.join(__dirname, 'models-db.json'),
+  catalogPath: path.join(__dirname, 'providers.json'),
+  configPath: path.join(__dirname, 'config.json'),
+  keys: {
+    openrouter: process.env.PROVIDER_OPENROUTER_APIKEY || '',
+    huggingface: process.env.HF_TOKEN || process.env.PROVIDER_HF_APIKEY || '',
+    groq: process.env.PROVIDER_GROQ_APIKEY || '',
+    mistral: process.env.PROVIDER_MISTRAL_APIKEY || '',
+    gemini: process.env.PROVIDER_GEMINI_APIKEY || '',
+    cerebras: process.env.PROVIDER_CEREBRAS_APIKEY || '',
+    deepseek: process.env.PROVIDER_DEEPSEEK_APIKEY || '',
+    nim: process.env.PROVIDER_NIM_APIKEY || '',
+  },
+  fetchImpl: (url, opts) => fetch(url, opts),
+  config: MODEL_MANAGER_CONFIG,
+  reload: () => { try { reloadProviders(); } catch {} },
+  log: (msg) => logger.info('[modelManager] ' + msg),
+});
+
 // Health check
 const healthIntervals = {}; // key -> { nextCheck, backoff }
 
@@ -123,6 +208,26 @@ async function healthCheck() {
 setInterval(healthCheck, 30000);
 setTimeout(healthCheck, 1000);
 
+// Периодический сейв долговременной памяти (вдобавок к shutdown).
+if (memStore) setInterval(() => memStore.save(), 60000);
+
+// Извлекает usage из SSE-чанка (если провайдер шлёт его в последнем чанке).
+function collectReasonUsage(str, usageObj) {
+  if (!str || !/data: /.test(str)) return;
+  for (const line of str.split('\n')) {
+    const m = line.match(/^data: (.+)$/);
+    if (!m || m[1].trim() === '[DONE]') continue;
+    try {
+      const obj = JSON.parse(m[1]);
+      if (obj.usage && (obj.usage.prompt_tokens || obj.usage.completion_tokens)) {
+        usageObj.prompt_tokens = obj.usage.prompt_tokens;
+        usageObj.completion_tokens = obj.usage.completion_tokens;
+        usageObj.total_tokens = obj.usage.total_tokens;
+      }
+    } catch {}
+  }
+}
+
 // Извлекает все значения content из SSE-чанка. Возвращает true, если есть
 // хотя бы одно непустое (реальный токен, а не пустая дельта).
 function chunkHasToken(str) {
@@ -134,6 +239,22 @@ function chunkHasToken(str) {
   return false;
 }
 
+// Последний user-текст — для оценки, насколько короткий ответ легитимен.
+function lastUserText(messages) {
+  if (!Array.isArray(messages)) return '';
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m && m.role === 'user') {
+      if (typeof m.content === 'string') return m.content;
+      if (Array.isArray(m.content)) {
+        const t = m.content.filter(c => c && c.type === 'text').map(c => c.text || '').join(' ');
+        if (t) return t;
+      }
+    }
+  }
+  return '';
+}
+
 // Chat completion handler
 async function handleChatCompletion(req, res, body) {
   const requestedModel = body.model || 'tier-splus';
@@ -144,6 +265,12 @@ async function handleChatCompletion(req, res, body) {
   let effectiveModel = maybeUpgradeTier(requestedModel, complexity);
   let targetProviderKey = MODEL_MAP[effectiveModel] || MODEL_MAP[requestedModel] || 'zai';
   const isStreaming = body.stream === true;
+  // --- Контекстная телеметрия: один measure на запрос, record только в терминальной точке. ---
+  const measure = { ts: Date.now(), provider: targetProviderKey, cacheType: 'miss', status: 0, win: PROVIDERS[targetProviderKey]?.context_window || 0, upgraded: 0 };
+  const commit = (status) => {
+    measure.status = status;
+    contextStats.record(measure);
+  };
 
   // Vision detection: if the request contains images, route to a vision provider.
   // TWO-STAGE pipeline:
@@ -182,29 +309,41 @@ async function handleChatCompletion(req, res, body) {
     if (visionChain.length > 0) {
       logger.info('Vision pipeline: распознаю скриншот', { chain: visionChain.map(p => p.key).join(',') });
       let extracted = '';
-      for (const visionProvider of visionChain) {
-        try {
-          const visionBody = {
-            model: visionProvider.model,
-            messages: [{
-              role: 'user',
-              content: [
-                { type: 'text', text: 'Распознай и извлеки ВЕСЬ текст с изображения (ошибка, код, сообщение). Верни только содержимое, без комментариев. Если это код — верни код как есть.' },
-                ...(Array.isArray(body.messages) ? body.messages.flatMap((m) => (Array.isArray(m.content) ? m.content.filter((c) => c && (c.type === 'image_url' || c.type === 'image' || c.type === 'input_image')).map((c) => {
-                  // Normalize any image part to the universal image_url format
-                  const url = c.image_url?.url || c.image?.url || c.image?.data || (c.image && typeof c.image === 'string' ? c.image : null) || c.url;
-                  return url ? { type: 'image_url', image_url: { url } } : null;
-                }).filter(Boolean) : [])) : []),
-              ],
-            }],
-            max_tokens: 2000,
-          };
-          const visionRes = await callProvider(visionProvider, visionBody);
-          extracted = visionRes.data?.choices?.[0]?.message?.content || visionRes.data?.choices?.[0]?.message?.reasoning || '';
-          if (extracted) { logger.info('Vision pipeline: распознал ' + visionProvider.key); break; }
-        } catch (err) {
-          logger.warn('Vision pipeline: ' + visionProvider.key + ' не сработал', { error: err.message.slice(0, 80) });
+      // PARALLEL vision attempt: fire all vision providers at once and take the
+      // first one that extracts text. Previously each was tried IN SEQUENCE,
+      // so a slow/failed first provider meant the pipeline waited provider
+      // after provider — the "two chats think forever" pattern for screenshots.
+      const visionAttempts = visionChain.map((visionProvider) => (async () => {
+        const visionBody = {
+          model: visionProvider.model,
+          messages: [{
+            role: 'user',
+            content: [
+              { type: 'text', text: 'Распознай и извлеки ВЕСЬ текст с изображения (ошибка, код, сообщение). Верни только содержимое, без комментариев. Если это код — верни код как есть.' },
+              ...(Array.isArray(body.messages) ? body.messages.flatMap((m) => (Array.isArray(m.content) ? m.content.filter((c) => c && (c.type === 'image_url' || c.type === 'image' || c.type === 'input_image')).map((c) => {
+                // Normalize any image part to the universal image_url format
+                const url = c.image_url?.url || c.image?.url || c.image?.data || (c.image && typeof c.image === 'string' ? c.image : null) || c.url;
+                return url ? { type: 'image_url', image_url: { url } } : null;
+              }).filter(Boolean) : [])) : []),
+            ],
+          }],
+          max_tokens: 2000,
+        };
+        const visionRes = await callProvider(visionProvider, visionBody);
+        const text = visionRes.data?.choices?.[0]?.message?.content || visionRes.data?.choices?.[0]?.message?.reasoning || '';
+        if (text) {
+          logger.info('Vision pipeline: распознал ' + visionProvider.key);
+          return text;
         }
+        throw new Error(visionProvider.key + ': пустой OCR');
+      })());
+      // First provider to yield text wins; hard failures (429/5xx) are skipped
+      // without blocking the others. If ALL fail, extracted stays '' and the
+      // request proceeds without vision context (as before).
+      try {
+        extracted = await Promise.any(visionAttempts);
+      } catch {
+        logger.warn('Vision pipeline: все вижн-провайдеры не сработали', { tried: visionChain.map(p => p.key) });
       }
       const cleaned = stripThink(extracted, true);
       logger.info('Vision pipeline: скриншот распознан', { chars: cleaned.length });
@@ -233,13 +372,94 @@ async function handleChatCompletion(req, res, body) {
     }
   }
 
-  // Check cache (works for both streaming and non-streaming)
-  const cached = cache.get(effectiveModel, body.messages, body.temperature);
-  if (cached) {
-    logger.request({ model: requestedModel, provider: 'cache', status: 200, cached: true });
-    recordRecent({ model: requestedModel, provider: 'cache', status: 200, latency: 0, cached: true });
+  // Window-aware upgrade: если запрос не влезает в окно целевой модели (после
+  // vision-апгрейда target), компакция НЕ запускается — суммаризатор не должен
+  // сжимать контекст, который провайдер с большим окном возьмёт целиком.
+  const windowUpgraded = Array.isArray(body.messages) && body.messages.length > 0 &&
+    needsWindowUpgrade(PROVIDERS[targetProviderKey]?.context_window || 0, estimateTokens(body.messages));
+
+  // Compact overly large conversations so free models don't reject on context.
+  // Runs AFTER the vision pipeline (images already converted to text above).
+  // Skipped in window-upgrade mode — the big provider takes the raw context.
+  if (Array.isArray(body.messages)) measure.origTokens = estimateTokens(body.messages);
+  if (Array.isArray(body.messages) && body.messages.length > 0 && !windowUpgraded) {
+    body.messages = await prepareMessages(body.messages, { contextWindow: PROVIDERS[targetProviderKey]?.context_window || 0 });
+  }
+  // Контекстная телеметрия: токены после компакции + доля системного промпта.
+  if (Array.isArray(body.messages)) {
+    measure.sentTokens = estimateTokens(body.messages);
+    measure.est = measure.sentTokens;
+    measure.compacted = measure.sentTokens < measure.origTokens;
+    const sysChars = body.messages.filter(m => m && m.role === 'system').reduce((a, m) => a + (typeof m.content === 'string' ? m.content.length : 0), 0);
+    const allChars = body.messages.reduce((a, m) => a + (typeof (m && m.content) === 'string' ? m.content.length : 0), 0);
+    if (allChars > 0) measure.sysShare = sysChars / allChars;
+  }
+
+  // --- Long-term memory recall ---
+  // Подмешиваем релевантные факты из прошлых сессий (векторная память) как
+  // user-сообщение В НАЧАЛЕ диалога — после системных правил, до кэша. Так
+  // ключ кэша (normalize игнорирует system, но учитывает user) различает разные
+  // наборы фактов, и ответы не отравляются чужим кэшем.
+  if (memStore) {
+    try {
+      const userTexts = [];
+      const userMsgs = body.messages.filter(m => m && m.role === 'user');
+      for (const m of userMsgs.slice(-3)) {
+        if (typeof m.content === 'string') userTexts.push(m.content);
+        else if (Array.isArray(m.content)) userTexts.push(m.content.filter(c => c && c.type === 'text').map(c => c.text || '').join(' '));
+      }
+      const query = userTexts.join('\n').trim();
+      if (query.length > 20) {
+        const hits = memStore.recall(query, { topK: MEMORY_CONFIG.topK, minSimilarity: MEMORY_CONFIG.minSimilarity });
+        if (hits.length > 0) {
+          // Не подмешиваем факт, который уже покрыт резюме компактора или
+          // недавними сообщениями этой же сессии (защита от дублей).
+          const existing = body.messages
+            .filter(m => m && typeof m.content === 'string')
+            .map(m => m.content)
+            .concat(userTexts);
+          const fresh = hits.filter(f => !memStore.isCovered(f.text, existing));
+          if (fresh.length > 0) {
+            let memoryMsg = fresh.map(f => f.text).join('\n');
+            if (memoryMsg) {
+              const insertAt = body.messages.findIndex(m => m && m.role !== 'system');
+              const block = { role: 'user', content: '[Память: релевантные факты из прошлого]\n' + memoryMsg };
+              if (insertAt === -1) body.messages.unshift(block);
+              else body.messages.splice(insertAt, 0, block);
+              measure.memory = true;
+              logger.info('Memory recall', { facts: fresh.length, covered: hits.length - fresh.length });
+            }
+          }
+        }
+      }
+    } catch (err) {
+      logger.error('Memory recall error', { message: err.message });
+    }
+  }
+
+  // --- Методолог (инженерная дисциплина) ---
+  // Классифицируем задачу (coding/reasoning/search/chat) и вставляем короткий
+  // системный промпт-методолог после памяти, до кэша. System-сообщение
+  // игнорируется normalize, поэтому кэш-ключ не меняется. Методолог влияет
+  // только на реальные запросы к провайдеру (кэш-хиты его не видят).
+  let taskCategory = 'chat';
+  if (METHODOLOGY_CONFIG.enabled && Array.isArray(body.messages)) {
+    try {
+      taskCategory = classifyTask(body.messages);
+      const injected = injectMethodology(body.messages, taskCategory, METHODOLOGY_CONFIG);
+      if (injected !== body.messages) {
+        body.messages = injected;
+        measure.taskCategory = taskCategory;
+      }
+    } catch (err) {
+      logger.error('Methodology error', { message: err.message });
+    }
+  }
+
+  // Replays a previously cached completion (exact or semantic hit), preserving
+  // the stream/non-stream shape the client asked for.
+  function serveCached(res, cached, isStreaming) {
     if (isStreaming) {
-      // Replay cached answer as an SSE stream
       res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive' });
       const content = cached.choices?.[0]?.message?.content || '';
       res.write(`data: ${JSON.stringify({ id: 'chatcmpl-cached', object: 'chat.completion.chunk', created: Math.floor(Date.now() / 1000), model: cached.model, choices: [{ index: 0, delta: { role: 'assistant', content: '' }, finish_reason: null }] })}\n\n`);
@@ -247,13 +467,40 @@ async function handleChatCompletion(req, res, body) {
       res.write(`data: ${JSON.stringify({ id: 'chatcmpl-cached', object: 'chat.completion.chunk', created: Math.floor(Date.now() / 1000), model: cached.model, choices: [{ index: 0, delta: {}, finish_reason: 'stop' }] })}\n\n`);
       res.write('data: [DONE]\n\n');
       res.end();
-      return;
+    } else {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(cached));
     }
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify(cached));
+  }
+
+  // Check cache (works for both streaming and non-streaming)
+  const cached = cache.get(effectiveModel, body.messages, body.temperature);
+  if (cached) {
+    logger.request({ model: requestedModel, provider: 'cache', status: 200, cached: true });
+    recordRecent({ model: requestedModel, provider: 'cache', status: 200, latency: 0, cached: true });
+    measure.cacheType = 'exact';
+    commit(200);
+    serveCached(res, cached, isStreaming);
     return;
   }
 
+  // Semantic cache: same intent, rephrased wording → replay without a new LLM call.
+  if (SEMCACHE_CONFIG.enabled) {
+    const semantic = cache.getSemantic(effectiveModel, body.messages, body.temperature, SEMCACHE_CONFIG.minSimilarity);
+    if (semantic) {
+      logger.request({ model: requestedModel, provider: 'semcache', status: 200, cached: true });
+      recordRecent({ model: requestedModel, provider: 'semcache', status: 200, latency: 0, cached: true });
+      measure.cacheType = 'semcache';
+      commit(200);
+      serveCached(res, semantic.value, isStreaming);
+      return;
+    }
+  }
+
+  // Запрос реально идёт к провайдеру (кэш промахнулся) — только теперь помечаем
+  // апгрейд: кэш-хит апгрейдом не считается (апстрим-вызова не было).
+  if (windowUpgraded) measure.upgraded = 1;
+
   // Weighted selection among healthy providers
   const today = new Date().toISOString().slice(0, 10);
   // 'ratelimited' providers are alive but temporarily limited — include them
@@ -264,44 +511,102 @@ async function handleChatCompletion(req, res, body) {
     .filter(([_, p]) => p.enabled && !isCircuitOpen(p.key) && p.vision !== true &&
       (getHealth()[p.key]?.status === 'up' || getHealth()[p.key]?.status === 'ratelimited'));
 
+  // Window-aware routing: estimate the request size and only consider providers
+  // whose context window can actually hold it. This stops large requests from
+  // burning time falling through lfm (65k) / groq (131k) providers that reject
+  // them — they go straight to nemotron-35/dots-3/minimax (1M/512k windows).
+  // Only applies when the request is big enough to matter, so small/typical
+  // requests keep the full fast pool.
+  const requestTokens = estimateTokens(body.messages);
+  const MIN_WINDOW = 50000; // below this we don't filter (typical requests)
+  let windowPool = healthyProviders;
+  let upgradeNoCapable = false; // апгрейд, но ни один здоровый провайдер не держит запрос
+  if (requestTokens > MIN_WINDOW || windowUpgraded) {
+    const capable = healthyProviders.filter(([_, p]) => {
+      const win = p.context_window || 0;
+      // Unknown/0 window providers are kept (heuristic) — better to try than drop.
+      return win === 0 || win >= requestTokens;
+    });
+    if (capable.length > 0) {
+      windowPool = capable;
+    } else if (windowUpgraded) {
+      // Best-effort: запрос больше окна любого провайдера (minimax 1M не держит).
+      // Всё равно переполним — выберем самое большое окно ниже, минимизируя
+      // потери контекста; target исключён; OVERFLOW поймает телеметрия.
+      upgradeNoCapable = true;
+    }
+  }
+
   // Prefer providers below 90% of their daily limit; only fall back to
   // near-exhausted ones if that leaves nothing (avoids avoidable 429s).
-  let pool = healthyProviders;
-  const underLimit = healthyProviders.filter(([_, p]) => {
-    const limit = p.dailyLimit || 1000;
-    const used = (getStats().dailyUsage?.[p.key]?.[today]) || 0;
-    return used < limit * 0.9;
-  });
-  if (underLimit.length > 0) pool = underLimit;
+  // Крутящийся пул по дневным лимитам: провайдер, исчерпавший дневной лимит,
+  // исключается из выбора и не возвращается до сброса. Это лечит 429-спираль
+  // (модель с лимитом 50/день сгорает к обеду, дальше каждая попытка на ней —
+  // бесполезный 429). Остаёмся на живых; выгоревшие — только как крайний резерв.
+  const usedTodayFor = (key) => (getStats().dailyUsage?.[key]?.[today]) || 0;
+  const pool = (() => {
+    // Провайдеры, у которых дневной лимит ещё не исчерпан (strict < limit).
+    const exemptables = windowPool.filter(([_, p]) => {
+      const limit = p.dailyLimit || 0;
+      if (limit <= 0) return true; // нет лимита — считаем «бесконечным»
+      return usedTodayFor(p.key) < limit;
+    });
+    // Есть живые → только они. Все выгорели → вернуть весь пул (best-effort,
+    // bandit-штраф ниже сделает их маловероятными, но не невозможными).
+    return exemptables.length > 0 ? exemptables : windowPool;
+  })();
 
   let selected = [];
   if (pool.length > 0) {
-    const scored = pool.map(([key, provider]) => {
-      const h = getHealth()[key];
-      let score = h.score || 50;
-      const rawLat = h.latency || 0;
-      const lat = rawLat > 0 ? Math.max(rawLat, 100) : 500;
-      let weight = score / lat;
-      if (h.status === 'ratelimited') weight *= 0.05;
-      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;
-      return { key, provider, weight };
-    });
+    if (upgradeNoCapable) {
+      // Bandit здесь бессилен: все провайдеры в пуле переполнят окно (запрос
+      // больше самого большого). Берём самое большое окно — наименьшие потери.
+      selected = pool
+        .map(([k, p]) => ({ key: k, provider: p }))
+        .sort((a, b) => (b.provider.context_window || 0) - (a.provider.context_window || 0))
+        .slice(0, 1);
+    } else {
+      const scored = pool.map(([key, provider]) => {
+        const h = getHealth()[key];
+        let score = h.score || 50;
+        const rawLat = h.latency || 0;
+        const lat = rawLat > 0 ? Math.max(rawLat, 100) : 500;
+        let weight = score / lat;
+        if (h.status === 'ratelimited') weight *= 0.05;
+        if (key === targetProviderKey) weight *= 1.15;
+        // Методолог: категория задачи задаёт буст моделям подходящей категории,
+        // не исключая fallback. coding→coding, reasoning→reasoning, chat/search→general.
+        const cat = provider.category || 'general';
+        if (taskCategory === 'coding' && cat === 'coding') weight *= 1.5;
+        else if (taskCategory === 'reasoning' && cat === 'reasoning') weight *= 1.5;
+        else if ((taskCategory === 'chat' || taskCategory === 'search') && cat === 'general') weight *= 1.2;
+        // Простой факт/поиск не должен «думать вслух» на reasoning-модели:
+        // это дорого по лимитам и даёт размышления вместо краткого ответа.
+        if ((taskCategory === 'chat' || taskCategory === 'search') && cat === 'reasoning') weight *= 0.15;
+        else if ((taskCategory === 'chat' || taskCategory === 'search') && cat === 'vision') weight *= 0.3;
+        const dailyLimit = provider.dailyLimit || 0;
+        // Провайдер, исчерпавший дневной лимит (попал в пул лишь как крайний
+        // резерв, когда живы все выгорели), — сильно штрафуем, чтобы выбрать
+        // его только в безвыходной ситуации, а не в первой же попытке.
+        const usedToday = usedTodayFor(key);
+        if (dailyLimit > 0 && usedToday >= dailyLimit) weight *= 0.03;
+        else if (dailyLimit > 0 && usedToday >= dailyLimit * 0.9) weight *= 0.4;
+        return { key, provider, weight };
+      });
 
-    // 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]];
+      // 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
@@ -310,21 +615,37 @@ async function handleChatCompletion(req, res, body) {
     ? pool.map(([k, p]) => ({ key: k, provider: p })).filter(s => s.key !== selected[0].key)
       .sort((a, b) => (getHealth()[b.key]?.score || 0) - (getHealth()[a.key]?.score || 0))
     : [];
-  const enabledProviders = selected.length > 0
+  let enabledProviders = selected.length > 0
     ? [selected[0]].concat(restOfPool).map(s => [s.key, s.provider])
     : Object.entries(PROVIDERS).filter(([_, p]) => p.enabled)
       .sort((a, b) => (getHealth()[b[0]]?.score || 50) - (getHealth()[a[0]]?.score || 50));
 
-  // Ensure the requested model's mapped provider is at least IN the candidate
-  // list (it may have been filtered out), but DON'T force it to the front —
-  // the weighted selection above should pick the fastest/healthiest provider.
-  if (MODEL_MAP[requestedModel] && PROVIDERS[targetProviderKey]) {
-    if (!enabledProviders.some(([k]) => k === targetProviderKey)) {
-      enabledProviders.unshift([targetProviderKey, PROVIDERS[targetProviderKey]]);
+  // Put the requested model's mapped provider FIRST. It's the only provider
+  // guaranteed to accept this tier/model — the rest are fallbacks (many reject
+  // tier-* requests with 400/422). Trying them before the target produced huge
+  // serial fallback chains (10+ sequential HTTP calls per request), which looked
+  // like the "model thinking forever". Correct mapping beats weighted guessing.
+  // Skipped in window-upgrade mode: the target doesn't fit the request anyway.
+  // If the target is rate-limited or near/over its daily limit, DON'T put it
+  // first — otherwise every request burns a doomed 429 attempt on it and the
+  // pool collapses into a rate-limit spiral. Skip straight to the healthy pool.
+  if (!windowUpgraded && MODEL_MAP[requestedModel] && PROVIDERS[targetProviderKey]) {
+    const tHealth = getHealth()[targetProviderKey];
+    const tLimit = (getStats().dailyUsage?.[targetProviderKey]?.[today]) || 0;
+    const tCap = PROVIDERS[targetProviderKey].dailyLimit || 0;
+    const targetBurned = tHealth?.status === 'ratelimited' || (tCap > 0 && tLimit >= tCap * 0.9);
+    if (!targetBurned) {
+      enabledProviders = [
+        [targetProviderKey, PROVIDERS[targetProviderKey]],
+        ...enabledProviders.filter(([k]) => k !== targetProviderKey),
+      ];
+    } else {
+      logger.info('Target-first skip', { key: targetProviderKey, status: tHealth?.status, used: tLimit, cap: tCap });
     }
   }
 
   if (enabledProviders.length === 0) {
+    commit(503);
     res.writeHead(503, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify({ error: 'No providers available' }));
     return;
@@ -332,7 +653,13 @@ async function handleChatCompletion(req, res, body) {
 
   const errors = [];
 
-  for (const [key, provider] of enabledProviders) {
+  // Cap serial fallback attempts. Trying provider after provider sequentially
+  // made a single tier-* request walk 10+ providers (each a real HTTP call),
+  // looking like the model "thinks forever". target-first above fixes the common
+  // case (right provider immediately); this cap bounds the worst case.
+  const fallbackProviders = enabledProviders.slice(0, 5);
+
+  for (const [key, provider] of fallbackProviders) {
     if (isCircuitOpen(key)) {
       errors.push(key + ': circuit breaker open');
       continue;
@@ -354,14 +681,13 @@ async function handleChatCompletion(req, res, body) {
       getHealth()[key].latency = Math.min(result.latency || 0, 60000);
       getHealth()[key].lastCheck = Date.now();
 
-      // For non-stream, verify the response isn't empty BEFORE recording success.
       if (!isStreaming && result.data) {
-        delete result.data.nvext;
-        if (result.data.choices?.[0]) {
-          fixReasoningMessage(result.data.choices[0].message);
-          cleanMessage(result.data.choices[0].message);
-        }
-        if (isTooShort(result.data)) {
+         delete result.data.nvext;
+         if (result.data.choices?.[0]) {
+           fixReasoningMessage(result.data.choices[0].message);
+           cleanMessage(result.data.choices[0].message);
+         }
+         if (isTooShort(result.data, lastUserText(body.messages))) {
           // Пустой/мусорный ответ (провайдер-глитч) НЕ считается успехом — пробуем следующего.
           const msg = key + ': empty or too short response';
           errors.push(msg);
@@ -375,6 +701,7 @@ async function handleChatCompletion(req, res, body) {
       }
 
       if (isStreaming && result.stream) {
+        measure.provider = key;
         const chunks = [];
 
         // Очистка SSE-строки: убрать nvext, logprobs, think-блоки из дельт.
@@ -392,6 +719,7 @@ async function handleChatCompletion(req, res, body) {
         });
 
         // Сбор контент-токенов для кэша (strip think).
+        const streamUsage = {};
         const collect = (str) => {
           const lines = str.split('\n');
           for (const line of lines) {
@@ -401,6 +729,12 @@ async function handleChatCompletion(req, res, body) {
               const obj = JSON.parse(m[1]);
               const delta = obj.choices?.[0]?.delta?.content;
               if (typeof delta === 'string') chunks.push(stripThink(delta, false));
+              // OpenRouter / Nebius etc. put usage in a final chunk. Keep it.
+              if (obj.usage && (obj.usage.prompt_tokens || obj.usage.completion_tokens)) {
+                streamUsage.prompt_tokens = obj.usage.prompt_tokens;
+                streamUsage.completion_tokens = obj.usage.completion_tokens;
+                streamUsage.total_tokens = obj.usage.total_tokens;
+              }
             } catch {}
           }
         };
@@ -416,17 +750,29 @@ async function handleChatCompletion(req, res, body) {
           recordRecent({ model: requestedModel, provider: key, status: 200, latency: result.latency, cached: false });
           recordSelection(key, provider.model, requestedModel);
           const { Transform } = require('stream');
+          const reasonDec = new StringDecoder('utf8');
+          const reasonUsage = {};
           const cleaner = new Transform({
             transform(chunk, encoding, callback) {
-              const str = chunk.toString();
+              const str = reasonDec.write(chunk);
+              collectReasonUsage(str, reasonUsage);
               collect(str);
               callback(null, cleanStr(str));
+            },
+            flush(callback) {
+              const tail = reasonDec.end();
+              if (tail) { collectReasonUsage(tail, reasonUsage); collect(tail); const tailStr = cleanStr(tail); if (tailStr) this.push(tailStr); }
+              callback();
             }
           });
           result.stream.on('end', () => {
             const full = chunks.join('');
             // Bandit учится по качеству: пустой/мусорный стрим = фейл.
             recordBandit(complexityBucket, key, full.trim().length >= MIN_ANSWER_LEN);
+            if (Object.keys(reasonUsage).length > 0) {
+              recordTokens(key, reasonUsage);
+              if (reasonUsage.prompt_tokens) measure.real = reasonUsage.prompt_tokens;
+            }
             if (full.trim().length >= MIN_ANSWER_LEN) {
               cache.set(effectiveModel, body.messages, body.temperature, {
                 id: 'chatcmpl-cached',
@@ -437,11 +783,13 @@ async function handleChatCompletion(req, res, body) {
                 usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
               });
             }
+            commit(200);
             res.end();
           });
           result.stream.on('error', (err) => {
             logger.error('Stream error', { key, error: err.message });
             if (!isTransientLimit(err.statusCode)) recordBandit(complexityBucket, key, false);
+            commit(err.statusCode || 502);
             res.end();
           });
           result.stream.pipe(cleaner).pipe(res);
@@ -450,13 +798,24 @@ async function handleChatCompletion(req, res, body) {
 
         // Обычные модели: буферизуем до первого токена (макс 5 сек).
         // Заголовки не пишем сразу — если токена нет за 5 сек, fallback.
+        // StringDecoder держит частично пришедший multi-byte UTF-8 между чанками —
+        // иначе русский текст дробится на '' символ.
         const rawBuf = [];
+        const streamDec = new StringDecoder('utf8');
+        // Адаптивный таймаут первого токена: используем измеренную скорость
+        // провайдера (latency от реальных запросов). Быстрые провайдеры не ждут
+        // полные 5с перед fallback'ом, а медленные (но рабочие) не отбрасываются
+        // слишком рано. Диапазон 2.5-8с для защиты от обоих крайностей.
+        const knownLat = getHealth()[key]?.latency || 0;
+        const firstTokenWait = knownLat > 0
+          ? Math.max(2500, Math.min(8000, Math.round(knownLat * 2)))
+          : 5000;
         const firstToken = new Promise((resolve) => {
           let done = false;
-          const timer = setTimeout(() => { if (!done) { done = true; resolve(false); } }, 5000);
+          const timer = setTimeout(() => { if (!done) { done = true; resolve(false); } }, firstTokenWait);
           const finish = (ok) => { if (!done) { done = true; clearTimeout(timer); resolve(ok); } };
           result.stream.on('data', (chunk) => {
-            const str = chunk.toString();
+            const str = streamDec.write(chunk);
             rawBuf.push(str);
             collect(str);
             // Первый контент-токен: хотя бы одно непустое `"content":"..."` в чанке.
@@ -503,16 +862,27 @@ async function handleChatCompletion(req, res, body) {
 
         // Убираем наш 'data'-слушатель (он больше не нужен — данные уже
         // буферизованы в rawBuf и промыты). Дальше обрабатываем вручную.
+        // Продолжаем использовать ТОТ ЖЕ streamDec — иначе multi-byte UTF-8,
+        // разделённый границей буфера, превратится в '' .
         result.stream.removeAllListeners('data');
         result.stream.on('data', (chunk) => {
-          const str = chunk.toString();
+          const str = streamDec.write(chunk);
           collect(str);
           res.write(cleanStr(str));
         });
         result.stream.on('end', () => {
+          const tail = streamDec.end();
+          if (tail) {
+            collect(tail);
+            res.write(cleanStr(tail));
+          }
           const full = chunks.join('');
           // Bandit учится по качеству: обрыв/мусорный стрим = фейл.
           recordBandit(complexityBucket, key, full.trim().length >= MIN_ANSWER_LEN);
+          if (Object.keys(streamUsage).length > 0) {
+            recordTokens(key, streamUsage);
+            if (streamUsage.prompt_tokens) measure.real = streamUsage.prompt_tokens;
+          }
           if (full.trim().length >= MIN_ANSWER_LEN) {
             cache.set(effectiveModel, body.messages, body.temperature, {
               id: 'chatcmpl-cached',
@@ -523,11 +893,13 @@ async function handleChatCompletion(req, res, body) {
               usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
             });
           }
+          commit(200);
           res.end();
         });
         result.stream.on('error', (err) => {
           logger.error('Stream error', { key, error: err.message });
           if (!isTransientLimit(err.statusCode)) recordBandit(complexityBucket, key, false);
+          commit(err.statusCode || 502);
           res.end();
         });
         return;
@@ -541,6 +913,10 @@ async function handleChatCompletion(req, res, body) {
         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);
+        measure.provider = key;
+        measure.real = (result.data.usage && result.data.usage.prompt_tokens) ? result.data.usage.prompt_tokens : measure.sentTokens || 0;
+        measure.win = PROVIDERS[key]?.context_window || 0;
+        commit(200);
         cache.set(effectiveModel, body.messages, body.temperature, result.data);
         recordTokens(key, result.usage);
         res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -569,13 +945,24 @@ async function handleChatCompletion(req, res, body) {
         getHealth()[key].reason = 'не отвечает';
       }
       getHealth()[key].score = Math.max(0, (getHealth()[key].score || 50) - (statusCode === 429 ? 5 : 10));
-      recordFailure(key, statusCode);
-      // 404 = model not available for this account — disable permanently
+      recordFailure(key, statusCode, statusCode === 404 && err.providerSide ? { providerSide: true } : undefined);
+      // 404 = model not available. Two distinct flavors:
+      //  - plain 404 («does not exist») → disable permanently (model gone from OpenRouter).
+      //  - provider-side 404 (Nvidia quota/upstream failing) → NOT permanent — the model
+      //    may recover. Mark it down hard so routing prefers others, and let the periodic
+      //    health-check re-enable it when it comes back.
       if (statusCode === 404) {
-        provider.enabled = false;
-        getHealth()[key].status = 'disabled';
-        getHealth()[key].reason = 'отключён автоматически (404)';
-        logger.warn('Provider auto-disabled (404)', { key, model: provider.model });
+        if (err.providerSide) {
+          getHealth()[key].status = 'error';
+          getHealth()[key].reason = 'провайдер временно недоступен (404)';
+          getHealth()[key].score = Math.max(0, (getHealth()[key].score || 50) - 25);
+          logger.warn('Provider temporarily down (provider-side 404)', { key, model: provider.model });
+        } else {
+          provider.enabled = false;
+          getHealth()[key].status = 'disabled';
+          getHealth()[key].reason = 'отключён автоматически (404)';
+          logger.warn('Provider auto-disabled (404)', { key, model: provider.model });
+        }
       }
     }
   }
@@ -585,7 +972,7 @@ async function handleChatCompletion(req, res, body) {
   const allSoft = errors.length > 0 && errors.every(e => !/429|401|403|404/.test(e));
   if (allSoft && enabledProviders.length > 1) {
     await new Promise(r => setTimeout(r, 1500));
-    for (const [key, provider] of enabledProviders) {
+    for (const [key, provider] of fallbackProviders) {
       if (isCircuitOpen(key)) continue;
       try {
         const release = await acquire(key);
@@ -601,7 +988,7 @@ async function handleChatCompletion(req, res, body) {
             fixReasoningMessage(result.data.choices[0].message);
             cleanMessage(result.data.choices[0].message);
           }
-          if (isTooShort(result.data)) {
+if (isTooShort(result.data, lastUserText(body.messages))) {
             recordFailure(key, 0);
             recordRequest(key, false, key + ': empty or too short response (retry)');
             recordBandit(complexityBucket, key, false);
@@ -613,6 +1000,10 @@ async function handleChatCompletion(req, res, body) {
           recordBandit(complexityBucket, key, true);
           recordRecent({ model: requestedModel, provider: key, status: 200, latency: result.latency, cached: false });
           recordSelection(key, provider.model, requestedModel);
+          measure.provider = key;
+          measure.real = (result.data.usage && result.data.usage.prompt_tokens) ? result.data.usage.prompt_tokens : measure.sentTokens || 0;
+          measure.win = PROVIDERS[key]?.context_window || 0;
+          commit(200);
           cache.set(effectiveModel, body.messages, body.temperature, result.data);
           recordTokens(key, result.usage);
           res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -620,6 +1011,7 @@ async function handleChatCompletion(req, res, body) {
           return;
         }
         if (body.stream && result.stream) {
+          measure.provider = key;
           recordSuccess(key);
           recordRequest(key, true);
           recordRecent({ model: requestedModel, provider: key, status: 200, latency: result.latency, cached: false });
@@ -650,12 +1042,15 @@ async function handleChatCompletion(req, res, body) {
               return 'data: ' + JSON.stringify(obj);
             } catch { return match; }
           });
+          const retryDec = new StringDecoder('utf8');
           result.stream.on('data', (chunk) => {
-            const str = chunk.toString();
+            const str = retryDec.write(chunk);
             collectRetry(str);
             res.write(cleanRetry(str));
           });
           result.stream.on('end', () => {
+            const tail = retryDec.end();
+            if (tail) { collectRetry(tail); res.write(cleanRetry(tail)); }
             const full = chunks.join('');
             // Bandit учится по качеству в ретрае тоже.
             recordBandit(complexityBucket, key, full.trim().length >= MIN_ANSWER_LEN);
@@ -669,11 +1064,13 @@ async function handleChatCompletion(req, res, body) {
                 usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
               });
             }
+            commit(200);
             res.end();
           });
           result.stream.on('error', (err) => {
             logger.error('Stream error (retry)', { key, error: err.message });
             if (!isTransientLimit(err.statusCode)) recordBandit(complexityBucket, key, false);
+            commit(err.statusCode || 502);
             res.end();
           });
           return;
@@ -686,6 +1083,7 @@ async function handleChatCompletion(req, res, body) {
     }
   }
 
+  commit(502);
   res.writeHead(502, { 'Content-Type': 'application/json' });
   res.end(JSON.stringify({ error: { message: 'All providers failed', type: 'api_error', code: 'all_providers_failed', details: errors } }));
 }
@@ -715,12 +1113,145 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
+  if (parsedUrl.pathname === '/v1/reload' && req.method === 'POST') {
+    // Hot-reload providers.json + config.json without restarting the server.
+    // Auth-protected like the other admin endpoints.
+    if (AUTH_KEY) {
+      const apiKey = (req.headers.authorization || '').replace('Bearer ', '').trim();
+      const keyFromQuery = parsedUrl.searchParams.get('key');
+      if (apiKey !== AUTH_KEY && keyFromQuery !== AUTH_KEY) {
+        res.writeHead(401, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: { message: 'Invalid API key' } }));
+        return;
+      }
+    }
+    try {
+      const result = reloadProviders();
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, ...result }));
+    } catch (err) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: { message: 'Reload failed: ' + err.message } }));
+    }
+    return;
+  }
+
+  if (parsedUrl.pathname === '/v1/models-db' && req.method === 'GET') {
+    // Структурированная база моделей: паспорта + статистика + топ по скору.
+    if (AUTH_KEY) {
+      const apiKey = (req.headers.authorization || '').replace('Bearer ', '').trim();
+      const keyFromQuery = parsedUrl.searchParams.get('key');
+      if (apiKey !== AUTH_KEY && keyFromQuery !== AUTH_KEY) {
+        res.writeHead(401, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: { message: 'Invalid API key' } }));
+        return;
+      }
+    }
+    try {
+      const models = modelManager.db.all()
+        .map(m => ({
+          key: m.key, model: m.model, source: m.source, category: m.category,
+          contextWindow: m.contextWindow, dailyLimit: m.dailyLimit,
+          score: m.score || 0, status: m.status,
+          lastCheckedAt: m.lastCheckedAt || null, lastOkAt: m.lastOkAt || null,
+        }))
+        .sort((a, b) => b.score - a.score);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        stats: modelManager.db.stats(),
+        top: models.slice(0, 10),
+        models,
+        manager: { enabled: MODEL_MANAGER_CONFIG.enabled !== false, intervalHours: modelManager.config.intervalHours, running: modelManager._running },
+      }));
+    } catch (err) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: { message: err.message } }));
+    }
+    return;
+  }
+
+  // Парсим /v1/models/{key}/toggle и /v1/models/{key}/test
+  const modelActionMatch = parsedUrl.pathname.match(/^\/v1\/models\/([^/]+)\/(toggle|test)$/);
+  if (modelActionMatch && req.method === 'POST') {
+    if (AUTH_KEY) {
+      const apiKey = (req.headers.authorization || '').replace('Bearer ', '').trim();
+      const keyFromQuery = parsedUrl.searchParams.get('key');
+      if (apiKey !== AUTH_KEY && keyFromQuery !== AUTH_KEY) {
+        res.writeHead(401, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: { message: 'Invalid API key' } }));
+        return;
+      }
+    }
+    const modelKey = decodeURIComponent(modelActionMatch[1]);
+    const action = modelActionMatch[2];
+
+    if (action === 'test') {
+      // Живой "hi"-тест: работает ли модель с нашим ключом. Без изменения каталога.
+      const dbEntry = modelManager.db.get(modelKey);
+      const prov = PROVIDERS[modelKey];
+      const endpoint = (dbEntry && dbEntry.endpoint) || (prov && prov.endpoint);
+      const model = (dbEntry && dbEntry.model) || (prov && prov.model);
+      if (!endpoint || !model) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Модель ' + modelKey + ' не найдена' }));
+        return;
+      }
+      const source = (dbEntry && dbEntry.source) || 'unknown';
+      const apiKey = modelManager.apiKeyFor(source);
+      try {
+        const t0 = Date.now();
+        const r = await fetch(endpoint, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', ...(apiKey ? { Authorization: 'Bearer ' + apiKey } : {}) },
+          body: JSON.stringify({ model, messages: [{ role: 'user', content: 'hi' }], max_tokens: 5 }),
+          signal: AbortSignal.timeout(20000),
+        });
+        const latencyMs = Date.now() - t0;
+        // Обновляем базу результатом проверки (но не «активируем» принудительно).
+        modelManager.db.markChecked(modelKey, { ok: r.ok, status: r.status, latencyMs }, { now: Date.now() });
+        modelManager.db.save();
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: r.ok, status: r.status, latencyMs, model: { key: modelKey, status: modelManager.db.get(modelKey).status } }));
+      } catch (err) {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, status: 0, error: err.message }));
+      }
+      return;
+    }
+
+    // action === 'toggle': вкл/выкл провайдера в config.json (только этот ключ) + hot-reload.
+    try {
+      const userCfg = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+      if (!userCfg.providers) userCfg.providers = {};
+      if (!userCfg.providers[modelKey]) userCfg.providers[modelKey] = {};
+      // Flip: было включено → выключить, было выключено → включить.
+      const currentlyEnabled = !(userCfg.providers[modelKey].enabled === false);
+      const newEnabled = !currentlyEnabled;
+      userCfg.providers[modelKey].enabled = newEnabled;
+      fs.writeFileSync(CONFIG_PATH, JSON.stringify(userCfg, null, 2));
+      reloadProviders();
+      // Статус в базе: включили → untested (проверится в след. цикле), выключили → user-disabled.
+      const entry = modelManager.db.get(modelKey);
+      if (entry) {
+        modelManager.db.setStatus(modelKey, newEnabled ? 'untested' : 'user-disabled');
+        modelManager.db.save();
+      }
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, key: modelKey, enabled: newEnabled, model: entry ? { key: modelKey, status: modelManager.db.get(modelKey).status } : null }));
+    } catch (err) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: { message: 'Toggle failed: ' + err.message } }));
+    }
+    return;
+  }
+
   if (parsedUrl.pathname === '/health') {
     const h = getHealth();
     const upCount = Object.values(h).filter(v => v.status === 'up').length;
     const totalCount = Object.entries(PROVIDERS).filter(([_, p]) => p.enabled).length;
+    const contextSummary = (() => { try { return contextStats.summary(); } catch { return null; } })();
     res.writeHead(upCount > 0 ? 200 : 503, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ status: upCount > 0 ? 'ok' : 'degraded', providers: { up: upCount, total: totalCount } }));
+    res.end(JSON.stringify({ status: upCount > 0 ? 'ok' : 'degraded', providers: { up: upCount, total: totalCount }, context: contextSummary }));
     return;
   }
 
@@ -738,6 +1269,14 @@ const server = http.createServer(async (req, res) => {
     res.end(JSON.stringify({
       total_requests: s.totalRequests, successful_requests: s.successfulRequests, failed_requests: s.failedRequests,
       provider_usage: s.providerUsage, token_usage: s.tokenUsage, errors: s.errors, uptime_seconds: Math.floor((Date.now() - s.startTime) / 1000),
+      today: (() => {
+        const r = getReliability();
+        let success = 0, fail = 0;
+        for (const [_, v] of Object.entries(r)) { if (v && v.day === today) { success += v.success || 0; fail += v.fail || 0; } }
+        const total = success + fail;
+        return { requests: total, success, failed: fail, successRate: total > 0 ? Math.round((success / total) * 100) : 0 };
+      })(),
+      savings: (() => { try { return aggregateSavings(s.tokenUsage || {}); } catch { return null; } })(),
       health: Object.fromEntries(Object.entries(getHealth()).map(([k, v]) => {
         const limit = limits[k];
         const err = s.errors[k] || 0;
@@ -756,6 +1295,7 @@ const server = http.createServer(async (req, res) => {
       pool: poolStats(),
       last_selection: getLastSelection(),
       bandit: getBandit(),
+      context_summary: (() => { try { return contextStats.summary(); } catch { return null; } })(),
     }));
     return;
   }
@@ -836,6 +1376,25 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
+  // POST /v1/cache/clear — drop the in-memory semantic cache without a restart.
+  // Handy when you tweaked providers/models and don't want stale answers served.
+  if (parsedUrl.pathname === '/v1/cache/clear' && req.method === 'POST') {
+    if (AUTH_KEY) {
+      const apiKey = (req.headers.authorization || '').replace('Bearer ', '').trim();
+      const keyFromQuery = parsedUrl.searchParams.get('key');
+      if (apiKey !== AUTH_KEY && keyFromQuery !== AUTH_KEY) {
+        res.writeHead(401, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: { message: 'Invalid API key' } }));
+        return;
+      }
+    }
+    const before = cache.stats().size || 0;
+    cache.clear();
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ ok: true, cleared: before }));
+    return;
+  }
+
   // POST /v1/shorts — generate a vertical short video via the tools generator.
   // Body: { prompt, duration?, format? ("9:16"/"16:9"/"1:1"), steps? }
   if (parsedUrl.pathname === '/v1/shorts' && req.method === 'POST') {
@@ -889,6 +1448,87 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
+  // --- Setup Dashboard API ---
+  if (parsedUrl.pathname === '/v1/setup/keys' && req.method === 'GET') {
+    const { keys } = readKeys();
+    // Mask keys for display; inputs stay EMPTY so we never send masked values back.
+    const masked = {};
+    const empty = {};
+    for (const [k, v] of Object.entries(keys)) {
+      empty[k] = '';
+      if (!v) { masked[k] = ''; continue; }
+      if (v.length <= 10) { masked[k] = v.slice(0, 2) + '***' + v.slice(-2); continue; }
+      masked[k] = v.slice(0, 4) + '***' + v.slice(-4);
+    }
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ groups: KEY_GROUPS, keys: empty, masked }));
+    return;
+  }
+
+  if (parsedUrl.pathname === '/v1/setup/keys' && req.method === 'POST') {
+    if (AUTH_KEY) {
+      const apiKey = (req.headers.authorization || '').replace('Bearer ', '').trim();
+      const keyFromQuery = parsedUrl.searchParams.get('key');
+      if (apiKey !== AUTH_KEY && keyFromQuery !== AUTH_KEY) {
+        res.writeHead(401, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: { message: 'Invalid API key' } }));
+        return;
+      }
+    }
+    let body = '';
+    req.on('data', (c) => body += c);
+    req.on('end', () => {
+      try {
+        const newKeys = JSON.parse(body);
+        // Only accept known env vars
+        const filtered = {};
+        for (const k of Object.keys(KEY_GROUPS)) {
+          if (typeof newKeys[k] === 'string') filtered[k] = newKeys[k];
+        }
+        const result = saveKeys(filtered);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: true, ...result }));
+      } catch (e) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: { message: 'Invalid request: ' + e.message } }));
+      }
+    });
+    return;
+  }
+
+  if (parsedUrl.pathname === '/v1/setup/validate') {
+    if (AUTH_KEY) {
+      const apiKey = (req.headers.authorization || '').replace('Bearer ', '').trim();
+      const keyFromQuery = parsedUrl.searchParams.get('key');
+      if (apiKey !== AUTH_KEY && keyFromQuery !== AUTH_KEY) {
+        res.writeHead(401, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: { message: 'Invalid API key' } }));
+        return;
+      }
+    }
+    const envVar = parsedUrl.searchParams.get('envVar');
+    let testKey = parsedUrl.searchParams.get('apiKey');
+    if (!envVar) {
+      res.writeHead(400, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: { message: 'envVar required' } }));
+      return;
+    }
+    // If apiKey param is empty/absent, validate the real stored key from .env.
+    if (!testKey) {
+      testKey = getStoredKey(envVar);
+    }
+    if (!testKey) {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ valid: false, error: 'Нет сохранённого ключа' }));
+      return;
+    }
+    validateKey(envVar, testKey).then((result) => {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(result));
+    });
+    return;
+  }
+
   res.writeHead(404, { 'Content-Type': 'application/json' });
   res.end(JSON.stringify({ error: 'Not found' }));
 });
@@ -896,7 +1536,19 @@ const server = http.createServer(async (req, res) => {
 server.listen(PORT, process.env.HOST || '127.0.0.1', () => {
   logger.info('Freegate started', { port: PORT });
   console.log('Dashboard: http://localhost:' + PORT + '/');
+  // Самообновляющаяся база моделей: первый цикл через 2 мин, далее по интервалу.
+  if (MODEL_MANAGER_CONFIG.enabled !== false) {
+    modelManager.start();
+    logger.info('ModelManager started', { intervalHours: modelManager.config.intervalHours });
+  }
 });
 
-process.on('SIGINT', () => { require('./lib/health').saveState(); cache.persist(); server.close(() => process.exit(0)); });
-process.on('SIGTERM', () => { require('./lib/health').saveState(); cache.persist(); server.close(() => process.exit(0)); });
+const _shutdown = () => {
+  if (memStore) { memStore.stopTimer(); memStore.save(); }
+  require('./lib/health').saveState();
+  cache.persist();
+  try { modelManager.stop(); } catch {}
+  server.close(() => process.exit(0));
+};
+process.on('SIGINT', _shutdown);
+process.on('SIGTERM', _shutdown);