freegate 0.6.20 → 0.6.22

package/README.md

@@ -37,6 +37,7 @@ sees your keys or conversations.**
 |---|---|
 | 🔀 **Auto-failover** | 50+ providers in one chain. Provider down? The next one answers. |
 | 🤖 **Self-managing models** | Auto-discovers new free models, tests them, adds working ones, disables dead ones — built-in scheduler, always-fresh model base. |
+| 🎛️ **Full manual control** | You decide what runs: enable/disable any provider or model, set your own keys (free **or paid**), and pick the routing mode. No magic hidden from you. |
 | 🗂️ **Model database** | Structured passport per model (score, latency, context window, history) + sorting: best models get routing priority. |
 | 🏷️ **Model categories** | reasoning / coding / general / vision / local — the right model for the right job. |
 | 🖼️ **Two-stage vision** | Screenshot → vision model reads it → coding model answers the fix. |
@@ -219,12 +220,37 @@ PROVIDER_ZAI_APIKEY=...        # ZAI
 **Providers** — catalog in `providers.json` (18 models). Add your own:
 put it in `config.json` → `providers` (same format as `providers.json`).
 
+**Paid providers + free↔paid routing** — Freegate normally uses only free models, but
+honors your own paid keys. Mark a provider paid in `config.json` → `providers` with
+`"paid": true` (or `"free": false`) and add its key in `.env`. Then choose how it's used:
+
+```json
+{ "routing": { "preference": "free-first" } }
+```
+
+- `free-first` (default) — free base in priority, your paid keys only as backup.
+- `paid-first` — your paid keys take priority, free as fallback.
+- `paid-fallback` — free by default; paid are touched only when free fail.
+
+> Example: put your DeepSeek or any OpenAI-compatible paid key under free gate,
+> and switch to `paid-fallback` so expensive calls only kick in when free providers are
+> down, not for every request.
+
+**Auto-update on the fly** — Freegate can rebase itself without you touching a chat:
+```json
+{ "autoUpdate": { "enabled": true, "intervalHours": 12 } }
+```
+Every interval it does `git fetch` + fast-forward `pull` on its own folder, then restarts
+the launchd service. Safe: it skips if the working tree is dirty (your local edits win),
+and never touches `.env`/`config.json` (gitignored).
+
 ## CLI commands
 
 ```bash
 npx freegate init              # create config
 npx freegate init -i           # interactive wizard (keys, password)
 npx freegate doctor            # diagnostics: keys, models, "what to check"
+npx freegate diag              # report: success rate, error classes, provider switches
 npx freegate start             # start proxy
 npx freegate status            # diagnostics: providers, limits, errors
 npx freegate test              # verify it works

package/README.ru.md

@@ -37,6 +37,7 @@ Freegate крутится **на твоей машине** (`http://localhost:40
 |---|---|
 | 🔀 **Автопереключение** | 50+ провайдеров в одной цепочке. Провайдер упал? Следующий уже отвечает. |
 | 🤖 **Автоуправление моделями** | Сам находит новые бесплатные модели, тестирует, добавляет рабочие, отключает мёртвые — встроенный планировщик, всегда актуальная база. |
+| 🎛️ **Полный ручной контроль** | Ты решаешь, что работает: включай/отключай любой провайдер или модель, подставляй свои ключи (бесплатные **или платные**) и выбирай режим роутинга. Никакой магии за твоей спиной. |
 | 🗂️ **База моделей** | Структурированный паспорт каждой модели (скор, латентность, окно, история) + сортировка: лучшие модели получают приоритет в роутинге. |
 | 🏷️ **Категории моделей** | reasoning / coding / general / vision / local — правильная модель для каждой задачи. |
 | 🖼️ **Vision-конвейер** | Скриншот → vision-модель читает → кодинг-модель отвечает на вопрос. |
@@ -223,6 +224,31 @@ PROVIDER_ZAI_APIKEY=...        # ZAI
 **Провайдеры** — каталог в `providers.json` (18 моделей). Добавить свой:
 впиши его в `config.json` → `providers` (формат как в `providers.json`).
 
+**Платные провайдеры + маршрутизация free↔paid.** По умолчанию Freegate использует
+только бесплатные модели, но уважает твои платные ключи. Пометь провайдера платным
+в `config.json` → `providers` флагом `"paid": true` (или `"free": false`) и добавь его
+ключ в `.env`. Затем выбери, как его использовать:
+
+```json
+{ "routing": { "preference": "free-first" } }
+```
+
+- `free-first` (по умолчанию) — бесплатная база в приоритете, твои платные ключи как запас.
+- `paid-first` — твои платные ключи в приоритете, бесплатные как fallback.
+- `paid-fallback` — по умолчанию бесплатные; платные трогаем, только когда бесплатные упали.
+
+> Пример: добавь свой ключ DeepSeek или любой OpenAI-совместимый под Freegate и переключись
+> на `paid-fallback` — дорогие вызовы будут идти только когда бесплатные провайдеры не
+> справились, а не на каждый запрос.
+
+**Автообновление на лету** — Freegate может обновляться сам, без твоего участия в чате:
+```json
+{ "autoUpdate": { "enabled": true, "intervalHours": 12 } }
+```
+Каждый интервал он делает `git fetch` + `pull` (fast-forward) в своей папке и перезапускает
+сервис launchd. Безопасно: пропускается, если рабочее дерево грязное (твои локальные правки
+важнее), и никогда не трогает `.env`/`config.json` (gitignored).
+
 **Методолог** — в `config.json`:
 
 ```json
@@ -247,6 +273,7 @@ PROVIDER_ZAI_APIKEY=...        # ZAI
 npx freegate init              # создать конфиг
 npx freegate init -i           # интерактивный мастер (ключи, пароль)
 npx freegate doctor            # диагностика: ключи, модели, «что проверить»
+npx freegate diag              # отчёт: успешность, классы ошибок, смена провайдеров
 npx freegate start             # запустить прокси
 npx freegate status            # диагностика: провайдеры, лимиты, ошибки
 npx freegate test              # проверить, что работает

package/bin/freegate.js

@@ -366,12 +366,49 @@ WantedBy=default.target
 } else if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
   const pkg = require(path.join(ROOT, 'package.json'));
   console.log(pkg.version);
+} else if (cmd === 'diag' || cmd === 'diagnose') {
+  const http = require('http');
+  const base = `http://127.0.0.1:${process.env.PORT || 4000}`;
+  const diag = require(path.join(ROOT, 'lib', 'diag'));
+  const g = (p) => new Promise((resolve) => {
+    http.get(base + p, (res) => {
+      let d = ''; res.on('data', (c) => d += c);
+      res.on('end', () => { try { resolve(JSON.parse(d)); } catch { resolve(null); } });
+    }).on('error', () => resolve(null));
+  });
+  (async () => {
+    const [stats, recent] = await Promise.all([g('/v1/stats'), g('/v1/recent')]);
+    if (!stats) { console.log('❌ Прокси не отвечает на ' + base + ' (запусти `npx freegate start`)'); process.exit(1); }
+    const r = diag.buildReport(stats, recent?.data || []);
+    const pct = (n, d) => d > 0 ? Math.round((n / d) * 100) + '%' : '—';
+    console.log('🔬 Freegate diag  (v' + r.version + ', uptime ' + Math.round((r.uptime || 0) / 60) + 'м)');
+    console.log('────────────────────────────────');
+    console.log('Сегодня: ' + r.today.requests + ' запросов → ' + r.today.success + ' успех, ' + r.today.failed + ' ошибок (' + (r.today.successRate ?? '—') + '%)');
+    console.log('Провайдеры: ' + r.providers.up + ' up · ' + r.providers.ratelimited + ' ratelimited · ' + r.providers.down + ' error (из ' + r.providers.total + ')');
+    console.log('Недавние: ' + r.recent.total + ' записей (' + r.recent.ok + ' ок, ' + r.recent.err + ' err, ' + r.recent.cached + ' из кэша), активно провайдеров: ' + r.recent.providersActive);
+    console.log('Контекст: ' + r.context.status + ' · компакций ' + r.context.compactCount + ' · over-window ' + r.context.overWindow + ' · апгрейдов ' + r.context.upgradedCount);
+    console.log('');
+    console.log('Ошибки по классам:');
+    for (const [cls, cnt] of Object.entries(r.classes)) {
+      console.log('  ' + (cnt > 0 ? '🟠' : '  ') + ' ' + cls.padEnd(9) + String(cnt).padStart(4) + '  ' + diag.LABELS[cls]);
+      if (cnt > 0 && diag.FIXES[cls]) console.log('     └→ ' + diag.FIXES[cls]);
+    }
+    console.log('');
+    const topErrors = Object.entries(r.errors).sort((a, b) => b[1].errors - a[1].errors).slice(0, 10);
+    if (topErrors.length) {
+      console.log('Топ провайдеров по ошибкам:');
+      for (const [k, v] of topErrors) {
+        console.log('  ' + String(v.errors).padStart(3) + '  ' + k.padEnd(34) + ' [' + v.status + '] ' + (v.reason || '').slice(0, 40));
+      }
+    }
+  })();
 } else {
   console.log('Freegate — бесплатный LLM-прокси с failover');
   console.log('Команды:');
   console.log('  npx freegate init       интерактивная настройка (quick/full режим, пароль)');
   console.log('  npx freegate start      запустить прокси');
   console.log('  npx freegate status     диагностика: провайдеры, лимиты, ошибки');
+  console.log('  npx freegate diag       отчёт: успешность, классы ошибок, смена провайдеров');
   console.log('  npx freegate test       проверить, что прокси работает');
   console.log('  npx freegate dashboard  открыть дашборд');
   console.log('  npx freegate install-service  автозапуск при старте системы');

package/config.example.json

@@ -29,12 +29,17 @@
     "complexityOnly": true
   },
   "routing": {
-    "strategy": "weighted"
+    "strategy": "weighted",
+    "preference": "free-first"
   },
   "compress": {
     "enabled": false,
     "minLen": 60
   },
+  "autoUpdate": {
+    "enabled": false,
+    "intervalHours": 12
+  },
   "providers": {
     "or-nemotron-550b": {
       "endpoint": "https://openrouter.ai/api/v1/chat/completions",

package/lib/autoupdate.js

@@ -0,0 +1,64 @@
+// Автообновление Freegate на лету: периодически проверяет новую версию
+// (git fetch) и при наличии апстрима делает fast-forward pull + перезапускает
+// сервис (launchd), не требуя действия от пользователя. Никогда не трогает
+// .env/config.json (gitignored) и не переживает локальные незакоммиченные
+// правки: при грязном рабочем дереве pull пропускается.
+const { execFile } = require('child_process');
+
+const DEFAULT_INTERVAL_HOURS = 12;
+const AUTO_UPDATE = () => {
+  const cfg = {};
+  try { Object.assign(cfg, require('../config.json').autoUpdate); } catch {}
+  return {
+    enabled: process.env.FREEGATE_AUTO_UPDATE ? process.env.FREEGATE_AUTO_UPDATE === '1' : !!cfg.enabled,
+    intervalMs: cfg.intervalHours ? cfg.intervalHours * 3600e3 : cfg.intervalMs || (DEFAULT_INTERVAL_HOURS * 3600e3),
+  };
+};
+
+function git(root, args) {
+  return new Promise((resolve) => {
+    execFile('git', args, { cwd: root, timeout: 30000 }, (err, stdout, stderr) => {
+      if (err) resolve({ ok: false, out: (stderr || stdout || '').trim() });
+      else resolve({ ok: true, out: (stdout || '').trim() });
+    });
+  });
+}
+
+async function checkForUpdate(root, log) {
+  const cfg = AUTO_UPDATE();
+  if (!cfg.enabled) return { skipped: true };
+  const fetch = await git(root, ['fetch', 'origin']);
+  if (!fetch.ok) return { ok: false, reason: 'fetch: ' + fetch.out };
+  // Рабочее дерево должно быть чистым, иначе pull может конфликтовать.
+  const status = await git(root, ['status', '--porcelain']);
+  if (status.out) return { ok: false, reason: 'грязное дерево (' + status.out.split('\n').length + ' файлов)' };
+  const diff = await git(root, ['rev-list', '--count', 'HEAD..@{u}']);
+  if (!diff.ok || diff.out.trim() === '0') return { ok: false, reason: 'нет новых коммитов' };
+  const ahead = Number(diff.out.trim());
+  const pull = await git(root, ['pull', '--ff-only', 'origin']);
+  if (!pull.ok) return { ok: false, reason: 'pull: ' + pull.out };
+  log('autoUpdate: pulled ' + ahead + ' commits, restarting service');
+  return { ok: true, pulled: ahead };
+}
+
+function restartService() {
+  const { execFileSync } = require('child_process');
+  try { execFileSync('launchctl', ['kickstart', '-k', 'gui/' + process.getuid() + '/com.free-llm-proxy']); }
+  catch (e) { try { execFileSync('kill', ['-HUP', String(process.pid)]); } catch {} }
+}
+
+function startAutoUpdate({ root, log }) {
+  const cfg = AUTO_UPDATE();
+  if (!cfg.enabled) return;
+  const tick = () => {
+    checkForUpdate(root, log).then((r) => {
+      if (r.ok) {
+        setTimeout(() => { restartService(); }, 800);
+      }
+    }).catch(() => {});
+  };
+  setTimeout(() => tick(), 60e3); // первый цикл через 1 мин, дальше по расписанию
+  setInterval(tick, cfg.intervalMs);
+}
+
+module.exports = { startAutoUpdate, checkForUpdate, DEFAULT_INTERVAL_HOURS };

package/lib/dashboard.js

@@ -94,6 +94,7 @@ const HTML = `<!DOCTYPE html>
       color: var(--accent-dim); font-weight: 700; font-size: 13px; border: 1px solid var(--border); }
     .side-user .info .role { font-size: 11px; color: var(--muted); }
     .side-user .info .email { font-size: 12.5px; font-weight: 600; }
+    .side-user .info .version { font-size: 10.5px; font-weight: 500; color: var(--accent-dim); margin-left: 2px; }
 
     /* ── Контент ── */
     #main { flex: 1; min-width: 0; display: flex; flex-direction: column; }
@@ -197,7 +198,12 @@ const HTML = `<!DOCTYPE html>
     .mini-btn { padding: 6px 11px; border-radius: var(--radius-sm); border: 1px solid var(--border); background: var(--panel2);
       color: var(--text); font-size: 12px; cursor: pointer; transition: all .15s ease; font-weight: 500; }
     .mini-btn:hover { border-color: var(--accent); color: var(--accent-ink); }
-    .mini-btn.off { color: var(--warn); }
+    .mini-btn.on { color: var(--ok); border-color: rgba(74,222,128,.35); }
+    .mini-btn.off { color: var(--warn); border-color: rgba(251,191,36,.35); }
+    .test-res { font-size: 11px; margin-left: 6px; min-width: 56px; }
+    .test-res.testing { color: var(--accent-dim); }
+    .test-res.ok { color: var(--ok); }
+    .test-res.fail { color: var(--err); }
 
     /* ── Рекомендации ── */
     .rec { font-size: 12.5px; margin-bottom: 7px; line-height: 1.6; }
@@ -221,6 +227,10 @@ const HTML = `<!DOCTYPE html>
     .setup-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(340px, 1fr)); gap: 14px; }
     .key-card { background: var(--panel); border-radius: var(--radius); padding: 18px 20px; border: 1px solid var(--border); }
     .key-card h3 { color: var(--text); font-size: 15px; margin-bottom: 6px; font-weight: 700; }
+    .key-head { display: flex; align-items: center; justify-content: space-between; gap: 8px; }
+    .key-head h3 { margin: 0; }
+    .key-actions { display: flex; gap: 8px; margin-top: 10px; }
+    .key-link { color: var(--accent-ink); text-decoration: none; }
     .key-card .desc { color: var(--muted); font-size: 12.5px; margin-bottom: 10px; line-height: 1.5; }
     .key-card ol { color: var(--muted); font-size: 12px; padding-left: 18px; margin-bottom: 10px; }
     .key-card li { margin-bottom: 4px; }
@@ -238,6 +248,19 @@ const HTML = `<!DOCTYPE html>
     .status-wait { color: var(--muted); font-size: 12px; }
     .hidden { display: none; }
 
+    /* ── Опции оптимизации ── */
+    .opt-row { display: flex; align-items: center; gap: 12px; margin: 12px 0 2px; font-size: 13.5px; font-weight: 600; }
+    .opt-switch { display: flex; align-items: center; gap: 10px; margin-left: auto; }
+    .switch { position: relative; display: inline-block; width: 40px; height: 22px; }
+    .switch input { display: none; }
+    .slider { position: absolute; inset: 0; background: var(--panel2); border: 1px solid var(--border); border-radius: 999px; cursor: pointer; transition: all .15s ease; }
+    .slider::before { content: ''; position: absolute; width: 16px; height: 16px; left: 2px; top: 2px; background: var(--muted); border-radius: 50%; transition: all .15s ease; }
+    .switch input:checked + .slider { background: rgba(124,92,255,.35); border-color: var(--accent); }
+    .switch input:checked + .slider::before { transform: translateX(18px); background: #fff; }
+    .opt-hint { font-size: 12px; color: var(--accent-dim); font-weight: 500; }
+    .opt-desc { font-size: 12px; color: var(--muted); line-height: 1.55; margin: 0 0 8px; }
+    .opt-note { font-size: 12px; color: var(--ok); margin-top: 8px; }
+
     @media (max-width: 900px) {
       #sidebar { width: 64px; padding: 20px 8px; }
       .side-brand .name, .tab .label, .side-user .info { display: none; }
@@ -263,6 +286,7 @@ const HTML = `<!DOCTYPE html>
         <div class="tab" data-i18n="tabProviders" onclick="showTab('providers')"></div>
         <div class="tab" data-i18n="tabModels" onclick="showTab('models')"></div>
         <div class="tab" data-i18n="tabContext" onclick="showTab('context')"></div>
+        <div class="tab" data-i18n="tabDiag" onclick="showTab('diag')"></div>
         <div class="tab" data-i18n="tabSetup" onclick="showTab('setup')"></div>
       </nav>
 
@@ -270,8 +294,8 @@ const HTML = `<!DOCTYPE html>
         <div class="side-user">
           <div class="side-avatar">F</div>
           <div class="info">
-            <div class="email">Freegate</div>
-            <div class="role">Admin</div>
+            <div class="email">Freegate <span id="fgVersion" class="version"></span></div>
+            <div class="role" data-i18n="sideRole"></div>
           </div>
         </div>
       </div>
@@ -368,6 +392,15 @@ const HTML = `<!DOCTYPE html>
       </div>
     </section>
 
+    <!-- ═══ ДИАГНОСТИКА ═══ -->
+    <section id="panel-diag" class="panel">
+      <div id="diagSummary" class="grid"></div>
+      <div class="card" style="margin-top:16px;">
+        <h2 data-i18n="diagErrors"></h2>
+        <div class="table-wrap"><table id="diagErrorsTable"></table></div>
+      </div>
+    </section>
+
     <!-- ═══ НАСТРОЙКИ ═══ -->
     <section id="panel-setup" class="panel">
       <div style="margin-bottom: 16px;">
@@ -375,6 +408,32 @@ const HTML = `<!DOCTYPE html>
         <button class="btn btn-save" data-i18n="saveAllKeys" onclick="saveAllKeys()" style="margin-left: 8px;"></button>
         <span id="save-status" class="status-wait" style="margin-left: 12px;"></span>
       </div>
+      <div class="card" style="margin-bottom:14px;">
+        <h2 data-i18n="optBlock"></h2>
+        <div class="opt-row"><span data-i18n="optCompress"></span><div class="opt-switch"><label class="switch"><input type="checkbox" id="optCompress"><span class="slider"></span></label><span class="opt-hint" id="optCompressState"></span></div></div>
+        <div class="opt-desc" data-i18n="optCompressDesc"></div>
+        <div class="opt-row"><span data-i18n="optVetting"></span><div class="opt-switch"><label class="switch"><input type="checkbox" id="optVetting"><span class="slider"></span></label><span class="opt-hint" id="optVettingState"></span></div></div>
+        <div class="opt-desc" data-i18n="optVettingDesc"></div>
+        <div class="opt-row"><span data-i18n="optRouting"></span>
+          <select id="optRouting" class="filter" onchange="saveOpts()">
+            <option value="weighted" data-i18n="optWeighted"></option>
+            <option value="weighted-roundrobin" data-i18n="optRoundrobin"></option>
+            <option value="weighted-least" data-i18n="optLeast"></option>
+          </select>
+          <span class="opt-hint" id="optRoutingState"></span>
+        </div>
+        <div class="opt-desc" data-i18n="optRoutingDesc"></div>
+        <div class="opt-row"><span data-i18n="optPreference"></span>
+          <select id="optPreference" class="filter" onchange="saveOpts()">
+            <option value="free-first" data-i18n="prefFreeFirst"></option>
+            <option value="paid-first" data-i18n="prefPaidFirst"></option>
+            <option value="paid-fallback" data-i18n="prefPaidFallback"></option>
+          </select>
+          <span class="opt-hint" id="optPreferenceState"></span>
+        </div>
+        <div class="opt-desc" data-i18n="optPreferenceDesc"></div>
+        <div class="opt-note" id="optSaveNote"></div>
+      </div>
       <div id="setup-grid" class="setup-grid" data-i18n="loading"></div>
     </section>
       </main>
@@ -395,6 +454,21 @@ const HTML = `<!DOCTYPE html>
       ru: {
         tabOverview: 'Обзор', tabProviders: 'Провайдеры', tabModels: 'Модели',
         tabContext: 'Контекст', tabSetup: 'Настройки (ключи)',
+        tabDiag: 'Диагностика',
+        diagErrors: 'Ошибки сегодня (по кодам и провайдерам)', diagProviders: 'Провайдеры и статус',
+        diagSuccessRate: 'Успешность', diagCategory: 'Класс', diagHits: 'Ошибок',
+        diagInvalid: 'Невалидные (400/422) — не лимит, чинится в коде', diagLimit: 'Лимит/429 — выгорание дневных лимитов',
+        diagTimeout: 'Таймаут/сетевые', diagAuth: '401/402/403 — ключ/баланс', diagFix: 'Фикс',
+        diagFixSanitize: 'санитизация reasoning_effort', diagFixAuth: 'исключение из роутинга',
+        diagFixLimit: 'предохранитель выгорания', diagFixTimeout: 'дольше холдить', diagNone: 'нет',
+        optBlock: 'Опции оптимизации', optCompress: 'Сжатие промптов', optVetting: 'Самопроверка', optRouting: 'Стратегия роутинга',
+        optWeighted: 'weighted (умный)', optRoundrobin: 'weighted-roundrobin (по кругу)', optLeast: 'weighted-least (меньше нагруженные)',
+        optCompressDesc: 'Убирает вежливость и «мусорные» слова («пожалуйста», «привет», «наверное») из последнего сообщения — меньше токенов, быстрее и дешевле. Не трогает код.',
+        optVettingDesc: 'Сложные ответы (код/рассуждения) проверяет второй моделью и помечает ошибки. Тратит один лишний запрос на проверку.',
+        optRoutingDesc: 'Как Freegate выбирает провайдера: умный взвешенный, по кругу (равномерно), или наименее нагруженные.', optSaved: 'Сохранено! Перезапусти Freegate для применения.',
+        optPreference: 'Предпочтение free↔paid',
+        prefFreeFirst: 'free-first (бесплатные в приоритете)', prefPaidFirst: 'paid-first (свои платные в приоритете)', prefPaidFallback: 'paid-fallback (платные — как запас)',
+        optPreferenceDesc: 'Как использовать твои платные ключи рядом с бесплатной базой: бесплатные всегда, свои платные в первую очередь, или платные только когда бесплатные упали. У платного провайдера в каталоге стоит флаг paid или free=false.',
         crumb: 'Админ', pageTitle: 'Панель управления', pageSub: 'Мониторинг и управление Freegate', topTitle: 'Панель управления',
         kpiProviders: 'Провайдеры', kpiRequests: 'Запросы', kpiRpm: 'RPM', kpiCache: 'Кэш',
         kpiToday: 'Успех сегодня', kpiLimit: 'Лимит', kpiModels: 'Модели', kpiUptime: 'Аптайм',
@@ -416,6 +490,7 @@ const HTML = `<!DOCTYPE html>
         thRecentTime: 'Время', thRecentModel: 'Модель', thRecentProvider: 'Провайдер', thRecentStatus: 'Статус', thRecentLatency: 'Задержка',
         allCategories: 'Все категории', allStatuses: 'Все статусы', allSources: 'Все источники',
         enable: 'Вкл', disable: 'Выкл', testNow: 'Тест', testing: 'Проверка...',
+        enabledShort: 'Вкл', disabledShort: 'Выкл',
         recBlock: 'Что включить', recActiveFree: 'Рабочие free — включи', recPaid: 'Платные/нестабильные', recLocal: 'Локальные (слабый Mac)',
         modelManagerInfo: 'Автопоиск', every: 'каждые', off: 'выключен', cycleRunning: 'цикл выполняется...',
         overviewLineOk: 'Всё работает штатно', overviewDown: 'Упали', overviewLimit: 'Лимит исчерпан',
@@ -424,6 +499,7 @@ const HTML = `<!DOCTYPE html>
         validateAll: 'Проверить все ключи', saveAllKeys: 'Сохранить все ключи',
         keySet: 'ключ установлен', keyMissing: 'не задан', checkKey: 'Проверить', valid: 'Ключ валиден', invalid: 'Неверный ключ',
         saving: 'Сохранение...', savedMsg: 'Сохранено! Перезапусти Freegate для применения.', saveErr: 'Ошибка сохранения',
+        saveKey: 'Сохранить ключ', savedKey: 'Ключ сохранён. Перезапусти Freegate.',
         ctxStatus: 'Статус', ctxReq: 'Запросов (24ч)', ctxRate: 'Rate (1/ч)', ctxAvgRatio: 'Avg ratio / окно',
         ctxMaxRatio: 'Max ratio', ctxNear: 'Впритык к окну', ctxOver: 'Поверх окна', ctxCompact: 'Компакций',
         ctxUpgrade: 'Апгрейдов (окно)', ctxCacheRate: 'Кэш-hit %', ctxSys: 'System-доля', ctxNarrow: 'Узкие',
@@ -433,6 +509,21 @@ const HTML = `<!DOCTYPE html>
       en: {
         tabOverview: 'Overview', tabProviders: 'Providers', tabModels: 'Models',
         tabContext: 'Context', tabSetup: 'Settings (keys)',
+        tabDiag: 'Diagnostics',
+        diagErrors: 'Today errors (by code & provider)', diagProviders: 'Providers and status',
+        diagSuccessRate: 'Success rate', diagCategory: 'Class', diagHits: 'Errors',
+        diagInvalid: 'Invalid (400/422) — not a limit, fixable in code', diagLimit: 'Rate/429 — daily limit burnout',
+        diagTimeout: 'Timeout/network', diagAuth: '401/402/403 — key/balance', diagFix: 'Fix',
+        diagFixSanitize: 'reasoning_effort sanitization', diagFixAuth: 'exclude from routing',
+        diagFixLimit: 'burnout guard', diagFixTimeout: 'backoff longer', diagNone: 'none',
+        optBlock: 'Optimization options', optCompress: 'Prompt compression', optVetting: 'Self-check', optRouting: 'Routing strategy',
+        optWeighted: 'weighted (smart)', optRoundrobin: 'weighted-roundrobin (round-robin)', optLeast: 'weighted-least (least-used)',
+        optCompressDesc: 'Strips politeness and filler words ("please", "hello", "probably") from the last message — fewer tokens, faster and cheaper. Never touches code.',
+        optVettingDesc: 'Complex answers (code/reasoning) get vetted by a second model and flagged on error. Costs one extra request per check.',
+        optRoutingDesc: 'How Freegate picks a provider: smart weighted, round-robin (even), or least-loaded.', optSaved: 'Saved! Restart Freegate to apply.',
+        optPreference: 'Free↔paid preference',
+        prefFreeFirst: 'free-first (free in priority)', prefPaidFirst: 'paid-first (your paid keys in priority)', prefPaidFallback: 'paid-fallback (paid as a fallback)',
+        optPreferenceDesc: 'How to use your paid keys alongside the free base: free always, your paid first, or paid only when free fail. Mark a paid provider with the paid flag (free=false) in the catalog.',
         crumb: 'Admin', pageTitle: 'Control Panel', pageSub: 'Freegate monitoring & management', topTitle: 'Control Panel',
         kpiProviders: 'Providers', kpiRequests: 'Requests', kpiRpm: 'RPM', kpiCache: 'Cache',
         kpiToday: 'Success today', kpiLimit: 'Limit', kpiModels: 'Models', kpiUptime: 'Uptime',
@@ -454,6 +545,7 @@ const HTML = `<!DOCTYPE html>
         thRecentTime: 'Time', thRecentModel: 'Model', thRecentProvider: 'Provider', thRecentStatus: 'Status', thRecentLatency: 'Latency',
         allCategories: 'All categories', allStatuses: 'All statuses', allSources: 'All sources',
         enable: 'On', disable: 'Off', testNow: 'Test', testing: 'Testing...',
+        enabledShort: 'On', disabledShort: 'Off',
         recBlock: 'What to enable', recActiveFree: 'Working free — enable', recPaid: 'Paid/unstable', recLocal: 'Local (weak Mac)',
         modelManagerInfo: 'Auto-discovery', every: 'every', off: 'off', cycleRunning: 'cycle running...',
         overviewLineOk: 'All systems operational', overviewDown: 'Down', overviewLimit: 'Limit exhausted',
@@ -462,6 +554,7 @@ const HTML = `<!DOCTYPE html>
         validateAll: 'Validate all keys', saveAllKeys: 'Save all keys',
         keySet: 'key set', keyMissing: 'not set', checkKey: 'Validate', valid: 'Key valid', invalid: 'Invalid key',
         saving: 'Saving...', savedMsg: 'Saved! Restart Freegate to apply.', saveErr: 'Save error',
+        saveKey: 'Save key', savedKey: 'Key saved. Restart Freegate.',
         ctxStatus: 'Status', ctxReq: 'Requests (24h)', ctxRate: 'Rate (1/h)', ctxAvgRatio: 'Avg ratio / window',
         ctxMaxRatio: 'Max ratio', ctxNear: 'Near window', ctxOver: 'Over window', ctxCompact: 'Compactions',
         ctxUpgrade: 'Upgrades (window)', ctxCacheRate: 'Cache-hit %', ctxSys: 'System share', ctxNarrow: 'Narrow',
@@ -511,7 +604,7 @@ const HTML = `<!DOCTYPE html>
     var _modelSort = { key: 'score', dir: -1 };
 
     // ── табы ──
-    var _tabByKey = { overview: 'tabOverview', providers: 'tabProviders', models: 'tabModels', context: 'tabContext', setup: 'tabSetup' };
+    var _tabByKey = { overview: 'tabOverview', providers: 'tabProviders', models: 'tabModels', context: 'tabContext', diag: 'tabDiag', setup: 'tabSetup' };
     function showTab(tab) {
       var key = _tabByKey[tab];
       document.querySelectorAll('#tabs .tab').forEach(function (t) {
@@ -561,6 +654,8 @@ const HTML = `<!DOCTYPE html>
         _ctxSummary = _statsData.context_summary || null;
         _savings = _statsData.savings || null;
         _hourly = _statsData.hourly || [];
+        var v = document.getElementById('fgVersion');
+        if (v) v.textContent = _statsData.version ? ('· v' + _statsData.version) : '';
         renderKpi();
         renderAlerts();
         renderOverviewCards();
@@ -569,6 +664,7 @@ const HTML = `<!DOCTYPE html>
         renderRecent(_recent);
         renderProvidersTable();
         renderContext(_ctxSummary);
+        renderDiag();
       }).catch(function (e) { console.error('Ошибка обновления:', e); });
     }
 
@@ -901,8 +997,9 @@ const HTML = `<!DOCTYPE html>
           '<td><span class="badge ' + esc(m.status) + '">' + esc(m.status) + '</span></td>' +
           '<td>' + fmtDate(m.lastCheckedAt) + '</td>' +
           '<td class="model-actions">' +
-            '<button class="mini-btn ' + (on ? '' : 'off') + '" onclick="toggleModel(\\'' + esc(m.key) + '\\')">' + (on ? '✓' : '✗') + '</button>' +
-            '<button class="mini-btn" onclick="testModelLive(\\'' + esc(m.key) + '\\')" title="' + t('testNow') + '">' + t('testNow') + '</button>' +
+            '<span class="mini-btn ' + (on ? 'on' : 'off') + '" onclick="toggleModel(\\'' + esc(m.key) + '\\')" title="' + (on ? t('disable') : t('enable')) + '">' + (on ? t('enabledShort') : t('disabledShort')) + '</span>' +
+            '<span class="mini-btn" onclick="testModelLive(\\'' + esc(m.key) + '\\', this)">' + t('testNow') + '</span>' +
+            '<span id="testres-' + esc(m.key) + '" class="test-res"></span>' +
           '</td></tr>';
       });
       document.getElementById('modelTable').innerHTML = html;
@@ -921,14 +1018,17 @@ const HTML = `<!DOCTYPE html>
         .then(function (d) { fetchModels(); renderKpi(); })
         .catch(function (e) { alert(e.message); });
     }
-    function testModelLive(key) {
+    function testModelLive(key, el) {
+      var res = document.getElementById('testres-' + key);
+      if (res) { res.className = 'test-res testing'; res.textContent = t('testing'); }
       fetch(_api('/v1/models/' + encodeURIComponent(key) + '/test'), { method: 'POST' })
         .then(function (r) { return r.json(); })
         .then(function (d) {
-          alert((d.ok ? 'OK' : 'FAIL (' + d.status + ')') + ' · ' + d.latencyMs + 'ms' + (d.error ? ' · ' + d.error : ''));
+          var ok = !!d.ok;
+          if (res) { res.className = 'test-res ' + (ok ? 'ok' : 'fail'); res.textContent = ok ? (d.latencyMs + 'ms ✓') : (d.status || 'FAIL'); }
           fetchModels();
         })
-        .catch(function (e) { alert(e.message); });
+        .catch(function (e) { if (res) { res.className = 'test-res fail'; res.textContent = 'ERR'; } });
     }
     function renderModelRecommend() {
       var el = document.getElementById('modelRecommend');
@@ -987,6 +1087,39 @@ const HTML = `<!DOCTYPE html>
       document.getElementById('taskBars').innerHTML = bars || '<div class="stat"><span class="stat-label">' + t('ctxNoTask') + '</span><span class="stat-value">—</span></div>';
     }
 
+    // ── Диагностика: успешность по кодам, классы ошибок, статусы провайдеров ──
+    function renderDiag() {
+      var s = _statsData || {};
+      var today = s.today || {};
+      var errors = s.errors || {};
+      var health = s.health || {};
+      var upCnt = 0, errCnt = 0, ratelimitedCnt = 0;
+      for (var ek in health) {
+        var v = health[ek];
+        if (v.status === 'up') upCnt++;
+        else if (v.status === 'ratelimited') ratelimitedCnt++;
+        else if (v.status === 'error') errCnt++;
+      }
+      var total = today.requests || 0;
+      var successRate = total > 0 ? Math.round((today.success / total) * 100) : 100;
+      document.getElementById('diagSummary').innerHTML =
+        '<div class="card"><h2>' + t('diagSuccessRate') + '</h2><div class="stat"><span class="stat-value" style="font-size:28px;color:' + limitColor(successRate) + '">' + successRate + '%</span>' +
+        '<span class="stat-label">' + today.success + ' / ' + total + '</span></div></div>' +
+        '<div class="card"><h2>Up</h2><div class="stat"><span class="stat-value">' + upCnt + '</span><span class="stat-label">status up</span></div></div>' +
+        '<div class="card"><h2>Limit</h2><div class="stat"><span class="stat-value" style="color:var(--warn)">' + ratelimitedCnt + '</span><span class="stat-label">429 (выгорели лимиты)</span></div></div>' +
+        '<div class="card"><h2>Error</h2><div class="stat"><span class="stat-value" style="color:var(--err)">' + errCnt + '</span><span class="stat-label">' + t('diagAuth') + '</span></div></div>';
+      var rows = Object.keys(errors).map(function (k) {
+        var st = health[k] || {};
+        return '<tr><td class="mono">' + esc(k) + '</td><td>' + errors[k] + '</td><td>' + esc(st.status || '?') + '</td><td>' + esc(st.reason || st.latency_ms || '') + '</td></tr>';
+      }).sort(function (a, b) {
+        var ma = a.match(/<td>(\d+)<\/td>/), mb = b.match(/<td>(\d+)<\/td>/);
+        return (mb ? parseInt(mb[1], 10) : 0) - (ma ? parseInt(ma[1], 10) : 0);
+      });
+      document.getElementById('diagErrorsTable').innerHTML = rows.length
+        ? '<tr><th>' + t('thKey') + '</th><th>count</th><th>status</th><th>reason</th></tr>' + rows.join('')
+        : '<div class="stat">' + t('diagNone') + '</div>';
+    }
+
     // ── Setup (API keys) ──
     var _setupData = null;
     async function loadSetup() {
@@ -995,7 +1128,42 @@ const HTML = `<!DOCTYPE html>
         _setupData = await res.json();
         renderSetup(_setupData);
       } catch (e) { console.error('Setup load error:', e); }
+      loadOpts();
+    }
+
+    // ── Опции оптимизации (compress/vetting/routing) ──
+    async function loadOpts() {
+      try {
+        var res = await fetch(_api('/v1/config'));
+        var c = await res.json();
+        document.getElementById('optCompress').checked = !!c.compress.enabled;
+        document.getElementById('optVetting').checked = !!c.vetting.enabled;
+        document.getElementById('optRouting').value = c.routing.strategy || 'weighted';
+        document.getElementById('optPreference').value = c.routing.preference || 'free-first';
+        var note = document.getElementById('optSaveNote');
+        if (note) note.textContent = '';
+      } catch (e) { console.error('Config load error:', e); }
     }
+    function saveOpts() {
+      var body = {
+        compress: { enabled: document.getElementById('optCompress').checked },
+        vetting: { enabled: document.getElementById('optVetting').checked },
+        routing: { strategy: document.getElementById('optRouting').value, preference: document.getElementById('optPreference').value },
+      };
+      fetch(_api('/v1/config'), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+      }).then(function (r) { return r.json(); }).then(function (d) {
+        var note = document.getElementById('optSaveNote');
+        if (note) note.textContent = d.ok ? (t('optSaved')) : (d.error || t('saveErr'));
+      }).catch(function (e) {
+        var note = document.getElementById('optSaveNote');
+        if (note) note.textContent = e.message;
+      });
+    }
+    document.getElementById('optCompress').addEventListener('change', saveOpts);
+    document.getElementById('optVetting').addEventListener('change', saveOpts);
     function renderSetup(data) {
       var grid = document.getElementById('setup-grid');
       var html = '';
@@ -1007,22 +1175,27 @@ const HTML = `<!DOCTYPE html>
         var steps = (isEn && info.steps_en) || info.steps;
         var maskedVal = (data.masked && data.masked[envVar]) || '';
         var stepsHtml = (steps || []).map(function (s) { return '<li>' + s + '</li>'; }).join('');
+        var stClass = maskedVal ? 'status-ok' : 'status-wait';
         html += '<div class="key-card" id="card-' + envVar + '">';
-        html += '<h3>' + esc(name) + '</h3>';
+        html += '<div class="key-head"><h3>' + esc(name) + '</h3><span id="badge-' + envVar + '" class="badge ' + (maskedVal ? 'active' : 'disabled') + '">' + (maskedVal ? '✓' : '—') + '</span></div>';
         html += '<div class="desc">' + esc(desc) + '</div>';
         html += '<ol>' + stepsHtml + '</ol>';
         html += '<div class="key-input-row">';
         html += '<input class="key-input" id="input-' + envVar + '" type="password" placeholder="' + (maskedVal ? t('keySet') + ' (' + maskedVal + ')' : t('checkKey') + '...') + '" autocomplete="off">';
+        html += '</div>';
+        html += '<div class="key-actions">';
         html += '<button class="btn btn-validate" data-validate="' + envVar + '">' + t('checkKey') + '</button>';
+        html += '<button class="btn btn-save" data-save="' + envVar + '">' + t('saveKey') + '</button>';
         html += '</div>';
-        html += '<div id="status-' + envVar + '" class="status-wait" style="margin-top: 6px;">' + (maskedVal ? t('keySet') + ' (' + maskedVal + ')' : t('keyMissing')) + '</div>';
-        html += '<a href="' + info.url + '" target="_blank" style="font-size: 11px;">' + esc(info.url) + '</a>';
+        html += '<div id="status-' + envVar + '" class="' + stClass + '" style="margin-top: 6px;">' + (maskedVal ? t('keySet') + ' (' + maskedVal + ')' : t('keyMissing')) + '</div>';
+        html += '<a href="' + info.url + '" target="_blank" class="key-link" style="font-size: 11px;">' + esc(info.url) + ' ↗</a>';
         html += '</div>';
       }
       grid.innerHTML = html;
     }
     document.addEventListener('click', function (e) {
       if (e.target.dataset && e.target.dataset.validate) validateKey(e.target.dataset.validate);
+      if (e.target.dataset && e.target.dataset.save) saveKey(e.target.dataset.save);
     });
     async function validateKey(envVar) {
       var input = document.getElementById('input-' + envVar);
@@ -1043,6 +1216,28 @@ const HTML = `<!DOCTYPE html>
         if (input && input.value.trim()) await validateKey(envVar);
       }
     }
+    async function saveKey(envVar) {
+      var input = document.getElementById('input-' + envVar);
+      var status = document.getElementById('status-' + envVar);
+      if (!input) return;
+      var key = input.value.trim();
+      status.className = 'status-wait'; status.textContent = t('saving');
+      try {
+        var res = await fetch(_api('/v1/setup/keys'), {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(((_k) => { var o = {}; o[_k] = key; return o; })(envVar))
+        });
+        var result = await res.json();
+        if (result.ok) {
+          status.className = 'status-ok'; status.textContent = t('savedKey');
+          var badge = document.getElementById('badge-' + envVar);
+          if (badge) { badge.className = 'badge active'; badge.textContent = '✓'; }
+        } else {
+          status.className = 'status-err'; status.textContent = (result.error || t('saveErr'));
+        }
+      } catch (e) { status.className = 'status-err'; status.textContent = e.message; }
+    }
     async function saveAllKeys() {
       var status = document.getElementById('save-status');
       status.className = 'status-wait'; status.textContent = t('saving');

package/lib/diag.js

@@ -0,0 +1,81 @@
+// Диагностика работы Freegate: успешность, классы ошибок, смена провайдеров.
+// Собирает отчёт из живых данных прокси (/v1/stats + /v1/recent). Читает только
+// публичные эндпоинты — можно гонять из любого окружения с доступом к порту.
+function classifyErr(statusCode, reason, providerSide) {
+  if (statusCode === 429) return 'limit';
+  if (statusCode === 401 || statusCode === 402 || statusCode === 403) return 'auth';
+  if (statusCode >= 400 && statusCode < 500) return 'invalid'; // 400/422 и т.п. — формат запроса
+  if (statusCode === 0) return 'timeout'; // соединение/таймаут
+  if (providerSide) return 'upstream'; // провайдер временно недоступен (5xx/404 upstream)
+  // health-статусы без атрибутов кода: reason подсказывает класс.
+  if (/много ошибок|лимит|429/i.test(reason || '')) return 'limit';
+  if (/не отвечает|недоступен|флап|timeout/i.test(reason || '')) return 'timeout';
+  return 'invalid';
+}
+
+function buildReport(stats, recent) {
+  const today = stats.today || {};
+  const errors = stats.errors || {};
+  const health = stats.health || {};
+  const ctx = stats.context_summary || {};
+  const total = today.requests || 0;
+  const success = today.success || 0;
+
+  const classes = { limit: 0, auth: 0, invalid: 0, timeout: 0, upstream: 0, other: 0 };
+  const byClass = {};
+  for (const [key, cnt] of Object.entries(errors)) {
+    const h = health[key] || {};
+    const cls = classifyErr(h.statusCode, h.reason, h.providerSide);
+    classes[cls] += cnt;
+    byClass[key] = { errors: cnt, status: h.status || '?', reason: h.reason || '' };
+  }
+
+  const up = Object.values(health).filter((h) => h.status === 'up').length;
+  const ratelimited = Object.values(health).filter((h) => h.status === 'ratelimited').length;
+  const down = Object.values(health).filter((h) => h.status === 'error').length;
+
+  // Недавние запросы — смена провайдеров / кэш.
+  let recentOk = 0, recentErr = 0, cached = 0;
+  const recentRows = Array.isArray(recent) ? recent : [];
+  for (const r of recentRows) {
+    if (r.cached) cached++;
+    if (r.status === 200 || r.status === undefined) recentOk++;
+    else recentErr++;
+  }
+
+  const switches = new Set();
+  for (const r of recentRows) if (r.provider && r.provider !== 'cache' && r.provider !== 'semcache') switches.add(r.provider);
+
+  return {
+    version: stats.version,
+    uptime: stats.uptime_seconds,
+    today: { requests: total, success, failed: today.failed || 0, successRate: total > 0 ? Math.round((success / total) * 100) : null },
+    classes,
+    errors: byClass,
+    providers: { total: Object.keys(health).length, up, ratelimited, down },
+    context: { status: ctx.status, compactCount: ctx.compactCount || 0, overWindow: ctx.overWindow || 0, upgradedCount: ctx.upgradedCount || 0, cacheHitRate: ctx.cacheHitRate || 0, taskTotal: ctx.taskTotal || 0 },
+    recent: { total: recentRows.length, ok: recentOk, err: recentErr, cached, providersActive: switches.size },
+    provider_usage: stats.provider_usage,
+    bandit: stats.bandit,
+    last_selection: stats.last_selection,
+  };
+}
+
+const LABELS = {
+  limit: 'лимит/429 (выгорание дневных лимитов)',
+  auth: '401/402/403 (неверный ключ или нет баланса)',
+  invalid: '400/422 (несовместимый формат запроса)',
+  timeout: 'таймаут/сетевое (провайдер не ответил)',
+  upstream: 'провайдер временно недоступен (5xx/upstream 404)',
+  other: 'прочее',
+};
+const FIXES = {
+  limit: 'предохранитель выгорания / расширить пул',
+  auth: 'проверить ключ/баланс в .env',
+  invalid: 'санитизация unsupported-полей (reasoning_effort и т.п.)',
+  timeout: 'увеличить backoff / дольше холдить флап-провайдеров',
+  upstream: 'обрабатывается автоматически (circuit breaker)',
+  other: 'смотреть логи',
+};
+
+module.exports = { buildReport, classifyErr, LABELS, FIXES };

package/lib/modelmanager.js

@@ -26,6 +26,13 @@ function inferSource(providerEntry) {
   const env = providerEntry.envVar || '';
   if (env.includes('OPENROUTER')) return 'openrouter';
   if (env.includes('HF')) return 'huggingface';
+  if (env.includes('SAMBANOVA')) return 'sambanova';
+  if (env.includes('SILICONFLOW')) return 'siliconflow';
+  if (env.includes('DEEPINFRA')) return 'deepinfra';
+  if (env.includes('HYPERBOLIC')) return 'hyperbolic';
+  if (env.includes('COHERE')) return 'cohere';
+  if (env.includes('LLM7')) return 'llm7';
+  if (env.includes('NARA')) return 'nara';
   const ep = providerEntry.endpoint || '';
   if (ep.includes('api.groq.com')) return 'groq';
   if (ep.includes('api.mistral.ai')) return 'mistral';
@@ -33,6 +40,13 @@ function inferSource(providerEntry) {
   if (ep.includes('api.cerebras.ai')) return 'cerebras';
   if (ep.includes('api.deepseek.com')) return 'deepseek';
   if (ep.includes('integrate.api.nvidia')) return 'nim';
+  if (ep.includes('api.sambanova.ai')) return 'sambanova';
+  if (ep.includes('api.siliconflow.com')) return 'siliconflow';
+  if (ep.includes('api.deepinfra.com')) return 'deepinfra';
+  if (ep.includes('api.hyperbolic.xyz')) return 'hyperbolic';
+  if (ep.includes('api.cohere.com')) return 'cohere';
+  if (ep.includes('api.llm7.io')) return 'llm7';
+  if (ep.includes('router.bynara.id')) return 'nara';
   return 'unknown';
 }
 

package/lib/providers.js

@@ -165,13 +165,28 @@ const MODEL_MAP = {
   'deepseek-v4-flash-vision-exp': 'deepseek-vision',
 };
 
+// Убирает поля, которые конкретный провайдер не принимает (иначе 400/422).
+// Например cohere-совместимые API лишают `reasoning_effort` → 400. Поля,
+// добавленные целенаправленно (tools/response_format), не трогаем — они не
+// сюда. `provider.unsupportedFields` задаётся в каталоге providers.json.
+function sanitizeBody(provider, body) {
+  const unsupported = provider.unsupportedFields || [];
+  if (unsupported.length === 0) return body;
+  const out = { ...body };
+  for (const f of unsupported) {
+    if (Object.prototype.hasOwnProperty.call(out, f)) delete out[f];
+  }
+  return out;
+}
+
 function callProvider(provider, body, timeout = 30000, retries = 1) {
   const isStreaming = body.stream === true;
+  const cleanBody = sanitizeBody(provider, body);
 
   return new Promise((resolve, reject) => {
     const attempt = (remaining) => {
       const startTime = Date.now();
-      const postData = JSON.stringify(body);
+      const postData = JSON.stringify(cleanBody);
       const url = new URL(provider.endpoint);
 
       const options = {
@@ -275,4 +290,4 @@ function callProvider(provider, body, timeout = 30000, retries = 1) {
   });
 }
 
-module.exports = { PROVIDERS, MODEL_MAP, callProvider, reloadProviders };
+module.exports = { PROVIDERS, MODEL_MAP, callProvider, reloadProviders, sanitizeBody };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "freegate",
-  "version": "0.6.20",
-  "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.",
+  "version": "0.6.22",
+  "description": "Free multi-provider LLM gateway with automatic failover. One OpenAI-compatible endpoint routes to many free models (Groq, Mistral, Gemini, NIM, OpenRouter, ZAI, Cerebras, DeepSeek and more). Never pay for LLMs.",
   "license": "MIT",
   "bin": {
     "freegate": "./bin/freegate.js"

package/providers.json

@@ -567,7 +567,11 @@
     "envVar": "PROVIDER_COHERE_APIKEY",
     "free": true,
     "category": "reasoning",
-    "context_window": 131072
+    "context_window": 131072,
+    "unsupportedFields": [
+      "reasoning_effort",
+      "thinking"
+    ]
   },
   "cohere-command-r-plus": {
     "endpoint": "https://api.cohere.com/compatibility/v1/chat/completions",
@@ -578,7 +582,11 @@
     "envVar": "PROVIDER_COHERE_APIKEY",
     "free": true,
     "category": "general",
-    "context_window": 131072
+    "context_window": 131072,
+    "unsupportedFields": [
+      "reasoning_effort",
+      "thinking"
+    ]
   },
   "llm7-gpt4o-mini": {
     "endpoint": "https://api.llm7.io/v1/chat/completions",
@@ -634,5 +642,75 @@
     "free": true,
     "category": "general",
     "context_window": 1000000
+  },
+  "gemini-gemma-4-26b-a4b-it": {
+    "endpoint": "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions",
+    "model": "gemma-4-26b-a4b-it",
+    "priority": 5,
+    "dailyLimit": 1500,
+    "keyHint": "gemini → Keys (автодобавлено, general)",
+    "envVar": "PROVIDER_GEMINI_APIKEY",
+    "free": true,
+    "category": "general"
+  },
+  "gemini-gemma-4-31b-it": {
+    "endpoint": "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions",
+    "model": "gemma-4-31b-it",
+    "priority": 1,
+    "dailyLimit": 1500,
+    "keyHint": "gemini → Keys (автодобавлено, general)",
+    "envVar": "PROVIDER_GEMINI_APIKEY",
+    "free": true,
+    "category": "general"
+  },
+  "gemini-gemini-flash-lite-latest": {
+    "endpoint": "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions",
+    "model": "gemini-flash-lite-latest",
+    "priority": 2,
+    "dailyLimit": 1500,
+    "keyHint": "gemini → Keys (автодобавлено, general)",
+    "envVar": "PROVIDER_GEMINI_APIKEY",
+    "free": true,
+    "category": "general"
+  },
+  "gemini-gemini-3-1-flash-lite-preview": {
+    "endpoint": "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions",
+    "model": "gemini-3.1-flash-lite-preview",
+    "priority": 6,
+    "dailyLimit": 1500,
+    "keyHint": "gemini → Keys (автодобавлено, general)",
+    "envVar": "PROVIDER_GEMINI_APIKEY",
+    "free": true,
+    "category": "general"
+  },
+  "gemini-gemini-3-5-flash": {
+    "endpoint": "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions",
+    "model": "gemini-3.5-flash",
+    "priority": 3,
+    "dailyLimit": 1500,
+    "keyHint": "gemini → Keys (автодобавлено, general)",
+    "envVar": "PROVIDER_GEMINI_APIKEY",
+    "free": true,
+    "category": "general"
+  },
+  "gemini-gemini-3-5-flash-lite": {
+    "endpoint": "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions",
+    "model": "gemini-3.5-flash-lite",
+    "priority": 4,
+    "dailyLimit": 1500,
+    "keyHint": "gemini → Keys (автодобавлено, general)",
+    "envVar": "PROVIDER_GEMINI_APIKEY",
+    "free": true,
+    "category": "general"
+  },
+  "gemini-gemini-3-1-flash-lite": {
+    "endpoint": "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions",
+    "model": "gemini-3.1-flash-lite",
+    "priority": 7,
+    "dailyLimit": 1500,
+    "keyHint": "gemini → Keys (автодобавлено, general)",
+    "envVar": "PROVIDER_GEMINI_APIKEY",
+    "free": true,
+    "category": "general"
   }
-}
+}

package/server.js

@@ -70,6 +70,7 @@ function getArg(name, defaultVal) {
 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 };
+const VERSION = (() => { try { return require('./package.json').version; } catch { return 'dev'; } })();
 
 // --- Долговременная память (vector memory) ---
 // По умолчанию включена: факты берутся побочно от компакции (без лишних вызовов
@@ -113,6 +114,12 @@ const VETTING_CONFIG = Object.assign(
 // По умолчанию 'weighted' — поведение без изменений.
 const { makeWeightModifier } = require('./lib/strategy');
 const ROUTING_STRATEGY = (config.routing && config.routing.strategy) || 'weighted';
+// Предпочтение free↔paid. Пользователь задаёт свои платные ключи (.env) и
+// выбирает, как их использовать рядом с бесплатной базой:
+//   free-first   — free в приоритете, paid только как запас (default).
+//   paid-first   — свои paid в приоритете, free как запас.
+//   paid-fallback— free по умолчанию, paid трогаем только если free упали.
+const ROUTING_PREFERENCE = (config.routing && config.routing.preference) || 'free-first';
 
 // --- Сжатие промпта (Caveman-стиль) ---
 // Опционально убирает вежливость/заполнители из последнего user-сообщения,
@@ -153,6 +160,8 @@ const MODEL_MANAGER_CONFIG = Object.assign(
   {},
   (config.modelManager && typeof config.modelManager === 'object') ? config.modelManager : {}
 );
+const autoUpdate = require('./lib/autoupdate');
+const AUTO_UPDATE = (config.autoUpdate && typeof config.autoUpdate === 'object') ? config.autoUpdate : {};
 const modelManager = new ModelManager({
   dbPath: path.join(__dirname, 'models-db.json'),
   catalogPath: path.join(__dirname, 'providers.json'),
@@ -676,6 +685,16 @@ async function handleChatCompletion(req, res, body) {
         const usedToday = usedTodayFor(key);
         if (dailyLimit > 0 && usedToday >= dailyLimit) weight *= 0.03;
         else if (dailyLimit > 0 && usedToday >= dailyLimit * 0.9) weight *= 0.4;
+        // Предпочтение free↔paid (config.routing.preference). Провайдер «платный»,
+        // если только у него есть ключ и он не помечен как free — free-first
+        // оставляет как есть (weight 1), paid-first бустит paid, paid-fallback
+        // дебустит paid, пока живы свободные (иначе он как раз нужен).
+        const isPaid = provider.paid === true || provider.free === false;
+        if (isPaid && ROUTING_PREFERENCE === 'paid-first') weight *= 2.5;
+        else if (isPaid && ROUTING_PREFERENCE === 'paid-fallback') {
+          const freeUp = pool && pool.length > 0;
+          weight *= freeUp ? 0.1 : 1.0;
+        }
         // Стратегия роутинга: равномерность (round-robin / least-used) как
         // лёгкий модификатор к базовому weight — не ломает основной скоринг.
         weight *= strategyModifier(key);
@@ -1055,6 +1074,16 @@ async function handleChatCompletion(req, res, body) {
       if (statusCode === 429) {
         getHealth()[key].status = 'ratelimited';
         getHealth()[key].reason = 'лимит провайдера (429)';
+      } else if (statusCode === 401 || statusCode === 402 || statusCode === 403) {
+        // Auth/баланс — НЕ транзиентная ошибка: ключ неверен или нет кредитов.
+        // Оставлять провайдера в пуле здесь бессмысленно — он будет получать
+        // запросы и каждый раз фейлиться. Сразу убираем из активной выборки.
+        // Периодический health-check/modelManager может вернуть его, когда
+        // ключ/баланс поправят (recheckDisabledDays).
+        getHealth()[key].status = 'error';
+        getHealth()[key].reason = statusCode === 401 ? 'неверный ключ' : statusCode === 402 ? 'нет средств/баланса' : 'доступ запрещён';
+        getHealth()[key].score = Math.max(0, (getHealth()[key].score || 50) - 25);
+        logger.warn('Provider auth/balance error, excluding from routing', { key, statusCode });
       } else if (statusCode !== 404 && getHealth()[key].status === 'up') {
         // keep 'up' — it may just be a transient blip; health-check re-verifies
       } else {
@@ -1253,6 +1282,57 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
+  if (parsedUrl.pathname === '/v1/config') {
+    // Чтение/запись опций оптимизации (compress/vetting/routing) в config.json.
+    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 userCfg = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+      if (req.method === 'GET') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          compress: { enabled: !!(userCfg.compress && userCfg.compress.enabled), minLen: userCfg.compress?.minLen || 60 },
+          vetting: { enabled: !!(userCfg.vetting && userCfg.vetting.enabled), minAnswerLen: userCfg.vetting?.minAnswerLen || 120, complexityOnly: userCfg.vetting?.complexityOnly !== false },
+          routing: { strategy: userCfg.routing?.strategy || 'weighted', preference: userCfg.routing?.preference || 'free-first' },
+        }));
+        return;
+      }
+      if (req.method === 'POST') {
+        let body = '';
+        req.on('data', (c) => { body += c; if (body.length > 100000) req.destroy(); });
+        req.on('end', () => {
+          try {
+            const patch = JSON.parse(body || '{}');
+            if (typeof patch.compress === 'object') userCfg.compress = Object.assign({ enabled: false, minLen: 60 }, userCfg.compress, patch.compress);
+            if (typeof patch.vetting === 'object') userCfg.vetting = Object.assign({ enabled: false, minAnswerLen: 120, complexityOnly: true }, userCfg.vetting, patch.vetting);
+            if (typeof patch.routing === 'object') userCfg.routing = Object.assign({ strategy: 'weighted', preference: 'free-first' }, userCfg.routing, patch.routing);
+            fs.writeFileSync(CONFIG_PATH, JSON.stringify(userCfg, null, 2));
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true }));
+          } catch (e) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: { message: 'Invalid config body: ' + e.message } }));
+          }
+        });
+        return;
+      }
+      res.writeHead(405, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: { message: 'Method not allowed' } }));
+      return;
+    } catch (err) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: { message: 'Config read failed: ' + err.message } }));
+      return;
+    }
+  }
+
   if (parsedUrl.pathname === '/v1/models-db' && req.method === 'GET') {
     // Структурированная база моделей: паспорта + статистика + топ по скору.
     if (AUTH_KEY) {
@@ -1384,6 +1464,7 @@ const server = http.createServer(async (req, res) => {
     }
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify({
+      version: VERSION,
       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: (() => {
@@ -1659,6 +1740,11 @@ server.listen(PORT, process.env.HOST || '127.0.0.1', () => {
     modelManager.start();
     logger.info('ModelManager started', { intervalHours: modelManager.config.intervalHours });
   }
+  // Автообновление на лету: git fetch + ff-pull + перезапуск, без действий юзера.
+  if (AUTO_UPDATE.enabled) {
+    autoUpdate.startAutoUpdate({ root: __dirname, log: (m) => logger.info(m) });
+    logger.info('AutoUpdate enabled', { intervalMs: AUTO_UPDATE.intervalMs });
+  }
 });
 
 const _shutdown = () => {