freegate 0.6.9 → 0.6.11

package/lib/normalize.js

@@ -45,21 +45,36 @@ function looksLikeCode(messages) {
 
 function normalizeMessages(messages) {
   if (!Array.isArray(messages)) return '';
-  const userOnly = messages.filter(m => m && m.role === 'user');
+  const dialog = messages.filter(m => m && (m.role === 'user' || m.role === 'assistant'));
   if (looksLikeCode(messages)) {
     // Код: точное совпадение, чтобы операторы не схлопывались в один ключ.
-    return JSON.stringify(userOnly);
+    return JSON.stringify(dialog);
   }
-  const userTexts = userOnly
+  // Включаем ВЕСЬ диалог (user + assistant), но НЕ system-промпт: короткие
+  // команды («продолжай») из разных диалогов с разным контекстом не должны
+  // схлопываться в один кэш-ключ и возвращать чужой ответ.
+  const texts = dialog
     .map(m => {
-      if (typeof m.content === 'string') return m.content;
-      if (Array.isArray(m.content)) {
-        return m.content.filter(c => c && c.type === 'text').map(c => c.text || '').join(' ');
+      const role = m.role === 'user' ? 'u' : 'a';
+      let body = '';
+      if (typeof m.content === 'string') body = m.content;
+      else if (Array.isArray(m.content)) {
+        body = m.content.filter(c => c && c.type === 'text').map(c => c.text || '').join(' ');
       }
+      return role + ':' + body;
+    })
+    .join('\n');
+  // Нет извлекаемого текста (только картинки/инструменты) → пусто, чтобы cache
+  // упал на точное совпадение (иначе image-only запросы схлопнутся в один ключ).
+  const rawText = dialog
+    .map(m => {
+      if (typeof m.content === 'string') return m.content;
+      if (Array.isArray(m.content)) return m.content.filter(c => c && c.type === 'text').map(c => c.text || '').join(' ');
       return '';
     })
     .join('\n');
-  return normalizeText(userTexts);
+  if (!rawText.trim()) return '';
+  return normalizeText(texts);
 }
 
 function normalizeText(text) {

package/lib/routing.js

@@ -57,4 +57,24 @@ function maybeUpgradeTier(requestedModel, complexity) {
   return requestedModel;
 }
 
-module.exports = { classifyComplexity, maybeUpgradeTier, COMPLEX_THRESHOLD };
+// Сложность СКРИНШОТА по распознанному тексту. Скриншоты с кодом/ошибками
+// должны поднимать тир (тяжёлая модель), простые фото — оставаться на лёгком.
+function classifyVisionComplexity(text) {
+  if (!text || typeof text !== 'string') return 0;
+  const t = text.trim();
+  if (t.length === 0) return 0;
+  let score = 0;
+  // Длина распознанного текста (до +0.2)
+  score += Math.min(t.length / 3000, 0.2);
+  // Код-признаки (до +0.4)
+  const codeMatches = (t.match(CODE_WORDS_EN) || []).length;
+  const ruMatches = (t.match(CODE_WORDS_RU) || []).length;
+  score += Math.min((codeMatches + ruMatches) * 0.08, 0.4);
+  // Error/fix слова (до +0.3)
+  if (FIX_WORDS.test(t)) score += 0.3;
+  // Символы кода { } [ ] => (до +0.3)
+  if (CODE_SYMBOLS.test(t)) score += 0.3;
+  return Math.min(score, 1);
+}
+
+module.exports = { classifyComplexity, maybeUpgradeTier, COMPLEX_THRESHOLD, classifyVisionComplexity };

package/package.json

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

package/providers.json

@@ -304,5 +304,75 @@
     "envVar": "PROVIDER_OPENROUTER_APIKEY",
     "free": true,
     "category": "vision"
+  },
+  "hf-Qwen3-8-2-4T-A95B": {
+    "endpoint": "https://router.huggingface.co/v1/chat/completions",
+    "model": "Qwen/Qwen3.8-2.4T-A95B",
+    "priority": 20,
+    "dailyLimit": 200,
+    "keyHint": "huggingface.co → Settings → Tokens (автодобавлено, general)",
+    "envVar": "PROVIDER_HF_APIKEY",
+    "free": true,
+    "category": "general"
+  },
+  "hf-GLM-5-2": {
+    "endpoint": "https://router.huggingface.co/v1/chat/completions",
+    "model": "zai-org/GLM-5.2",
+    "priority": 20,
+    "dailyLimit": 200,
+    "keyHint": "huggingface.co → Settings → Tokens (автодобавлено, general)",
+    "envVar": "PROVIDER_HF_APIKEY",
+    "free": true,
+    "category": "general"
+  },
+  "hf-gemma-4-31B-it": {
+    "endpoint": "https://router.huggingface.co/v1/chat/completions",
+    "model": "google/gemma-4-31B-it",
+    "priority": 20,
+    "dailyLimit": 200,
+    "keyHint": "huggingface.co → Settings → Tokens (автодобавлено, general)",
+    "envVar": "PROVIDER_HF_APIKEY",
+    "free": true,
+    "category": "general"
+  },
+  "hf-DeepSeek-V4-Pro": {
+    "endpoint": "https://router.huggingface.co/v1/chat/completions",
+    "model": "deepseek-ai/DeepSeek-V4-Pro",
+    "priority": 20,
+    "dailyLimit": 200,
+    "keyHint": "huggingface.co → Settings → Tokens (автодобавлено, general)",
+    "envVar": "PROVIDER_HF_APIKEY",
+    "free": true,
+    "category": "general"
+  },
+  "hf-gemma-4-26B-A4B-it": {
+    "endpoint": "https://router.huggingface.co/v1/chat/completions",
+    "model": "google/gemma-4-26B-A4B-it",
+    "priority": 20,
+    "dailyLimit": 200,
+    "keyHint": "huggingface.co → Settings → Tokens (автодобавлено, general)",
+    "envVar": "PROVIDER_HF_APIKEY",
+    "free": true,
+    "category": "general"
+  },
+  "hf-Llama-3-1-8B-Instruct": {
+    "endpoint": "https://router.huggingface.co/v1/chat/completions",
+    "model": "meta-llama/Llama-3.1-8B-Instruct",
+    "priority": 20,
+    "dailyLimit": 200,
+    "keyHint": "huggingface.co → Settings → Tokens (автодобавлено, general)",
+    "envVar": "PROVIDER_HF_APIKEY",
+    "free": true,
+    "category": "general"
+  },
+  "hf-DeepSeek-V4-Flash": {
+    "endpoint": "https://router.huggingface.co/v1/chat/completions",
+    "model": "deepseek-ai/DeepSeek-V4-Flash",
+    "priority": 20,
+    "dailyLimit": 200,
+    "keyHint": "huggingface.co → Settings → Tokens (автодобавлено, general)",
+    "envVar": "PROVIDER_HF_APIKEY",
+    "free": true,
+    "category": "general"
   }
 }

package/server.js

@@ -9,7 +9,7 @@ const { checkRateLimit } = require('./lib/rateLimit');
 const { handleDashboard } = require('./lib/dashboard');
 const { acquire, stats: poolStats } = require('./lib/pool');
 const { stripThink, cleanDelta, cleanMessage, fixReasoningMessage, hasContent } = require('./lib/clean');
-const { classifyComplexity, maybeUpgradeTier } = require('./lib/routing');
+const { classifyComplexity, maybeUpgradeTier, classifyVisionComplexity } = require('./lib/routing');
 const logger = require('./lib/logger');
 
 // Load persisted state
@@ -108,12 +108,11 @@ async function checkProvider(key, provider) {
 
 async function healthCheck() {
   const now = Date.now();
-  for (const [key, provider] of Object.entries(PROVIDERS)) {
-    if (!provider.enabled) continue;
-    const interval = healthIntervals[key];
-    if (interval && interval.nextCheck > now) continue;
-    await checkProvider(key, provider);
-  }
+  // Параллельный пробинг: все провайдеры проверяются одновременно,
+  // а не последовательно — быстрый старт и восстановление при 30+ провайдерах.
+  const due = Object.entries(PROVIDERS)
+    .filter(([key, provider]) => provider.enabled && !(healthIntervals[key] && healthIntervals[key].nextCheck > now));
+  await Promise.allSettled(due.map(([key, provider]) => checkProvider(key, provider)));
 }
 setInterval(healthCheck, 30000);
 setTimeout(healthCheck, 1000);
@@ -123,7 +122,7 @@ async function handleChatCompletion(req, res, body) {
   const requestedModel = body.model || 'tier-splus';
   // Умный роутинг: сложные задачи с лёгкого тира поднимаем на более мощный.
   // Классифицируем ПОСЛЕ того, как определён requestedModel, ДО выбора провайдера.
-  const effectiveModel = maybeUpgradeTier(requestedModel, classifyComplexity(body.messages));
+  let effectiveModel = maybeUpgradeTier(requestedModel, classifyComplexity(body.messages));
   let targetProviderKey = MODEL_MAP[effectiveModel] || MODEL_MAP[requestedModel] || 'zai';
   const isStreaming = body.stream === true;
 
@@ -191,6 +190,11 @@ async function handleChatCompletion(req, res, body) {
       const cleaned = stripThink(extracted, true);
       logger.info('Vision pipeline: скриншот распознан', { chars: cleaned.length });
       if (cleaned) {
+        // Умный vision-роутинг: скриншот с кодом/ошибкой поднимает тир.
+        const vc = classifyVisionComplexity(cleaned);
+        if (vc > 0) effectiveModel = maybeUpgradeTier(effectiveModel, vc);
+        // Пересчитываем target-провайдера — vision-апгрейд мог сменить тир.
+        targetProviderKey = MODEL_MAP[effectiveModel] || MODEL_MAP[requestedModel] || 'zai';
         // Replace image content with the extracted text as context,
         // so the coding/general model (not vision) answers the question.
         const userMsgs = Array.isArray(body.messages) ? body.messages : [];
@@ -346,6 +350,26 @@ async function handleChatCompletion(req, res, body) {
       // provider speed. Huge latency would poison the weighted selection.
       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 (!hasContent(result.data)) {
+          // Пустой ответ (провайдер-глитч) НЕ считается успехом — пробуем следующего.
+          const msg = key + ': empty response';
+          errors.push(msg);
+          recordFailure(key, 0);
+          recordRequest(key, false, msg);
+          recordRecent({ model: requestedModel, provider: key, status: 204, latency: result.latency, cached: false });
+          logger.warn('Empty response, trying next provider', { key });
+          continue;
+        }
+      }
+
       recordSuccess(key);
       recordRequest(key, true);
       logger.request({ model: requestedModel, provider: key, status: 200, latency: result.latency, stream: isStreaming });
@@ -413,12 +437,8 @@ async function handleChatCompletion(req, res, body) {
       }
 
       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 (hasContent(result.data)) cache.set(effectiveModel, body.messages, body.temperature, result.data);
+        // content already verified non-empty above
+        cache.set(effectiveModel, body.messages, body.temperature, result.data);
         recordTokens(key, result.usage);
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify(result.data));
@@ -470,22 +490,31 @@ async function handleChatCompletion(req, res, body) {
         } finally {
           release();
         }
-        recordSuccess(key);
-        recordRequest(key, true);
-        recordRecent({ model: requestedModel, provider: key, status: 200, latency: result.latency, cached: false });
         if (!body.stream && result.data) {
           delete result.data.nvext;
-        if (result.data.choices?.[0]) {
-          fixReasoningMessage(result.data.choices[0].message);
-          cleanMessage(result.data.choices[0].message);
-        }
-          if (hasContent(result.data)) cache.set(effectiveModel, body.messages, body.temperature, result.data);
+          if (result.data.choices?.[0]) {
+            fixReasoningMessage(result.data.choices[0].message);
+            cleanMessage(result.data.choices[0].message);
+          }
+          if (!hasContent(result.data)) {
+            recordFailure(key, 0);
+            recordRequest(key, false, key + ': empty response (retry)');
+            logger.warn('Empty response in retry, trying next', { key });
+            continue;
+          }
+          recordSuccess(key);
+          recordRequest(key, true);
+          recordRecent({ model: requestedModel, provider: key, status: 200, latency: result.latency, cached: false });
+          cache.set(effectiveModel, body.messages, body.temperature, result.data);
           recordTokens(key, result.usage);
           res.writeHead(200, { 'Content-Type': 'application/json' });
           res.end(JSON.stringify(result.data));
           return;
         }
         if (body.stream && result.stream) {
+          recordSuccess(key);
+          recordRequest(key, true);
+          recordRecent({ model: requestedModel, provider: key, status: 200, latency: result.latency, cached: false });
           res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive' });
           result.stream.pipe(res);
           return;