freegate 0.6.7 → 0.6.8

package/lib/cache.js

@@ -2,6 +2,7 @@
 const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
+const { normalizeMessages } = require('./normalize');
 
 const MAX_SIZE = 500;
 const DEFAULT_TTL = 3600000; // 1 hour in ms
@@ -9,17 +10,28 @@ const MAX_ENTRY_BYTES = 256 * 1024; // don't persist responses larger than 256KB
 const CACHE_PATH = path.join(__dirname, '..', 'cache.json');
 
 class LRUCache {
-  constructor(maxSize = MAX_SIZE, ttl = DEFAULT_TTL, skipLoad = false) {
+  constructor(maxSize = MAX_SIZE, ttl = DEFAULT_TTL, skipLoad = false, useNormalize = false) {
     this.maxSize = maxSize;
     this.ttl = ttl;
     this.cache = new Map();
     this.hits = 0;
     this.misses = 0;
+    this.useNormalize = useNormalize;
     if (!skipLoad) this.load();
   }
 
   _key(model, messages, temperature) {
-    const raw = `${model}|${JSON.stringify(messages)}|${temperature || 0}`;
+    let raw;
+    if (this.useNormalize) {
+      const norm = normalizeMessages(messages);
+      // Пустая нормализация (только картинки/инструменты без текста) НЕ должна
+      // схлопывать разные запросы в один ключ — fallback на точное совпадение.
+      raw = norm
+        ? `${model}|${norm}|${temperature || 0}`
+        : `${model}|${JSON.stringify(messages)}|${temperature || 0}`;
+    } else {
+      raw = `${model}|${JSON.stringify(messages)}|${temperature || 0}`;
+    }
     return crypto.createHash('sha256').update(raw).digest('hex').slice(0, 16);
   }
 

package/lib/normalize.js

@@ -0,0 +1,74 @@
+// Нормализация сообщений для семантического кэша.
+// Сравниваются только пользовательские текстовые сообщения, без system.
+
+const MAX_LEN = 2000;
+
+const CODE_SYMBOLS = new Set(['{', '}', '[', ']', '=>', ';', '=', '+', '-', '*', '/', '<', '>']);
+const CODE_KEYWORDS = new Set([
+  'function', 'const', 'let', 'var', 'return', 'import', 'export',
+  'class', 'def', '=>', 'await', 'async', 'try', 'catch', 'throw',
+]);
+
+function lastUserText(messages) {
+  if (!Array.isArray(messages)) return '';
+  const users = messages.filter(m => m && m.role === 'user');
+  const last = users[users.length - 1];
+  if (!last) return '';
+  if (typeof last.content === 'string') return last.content;
+  if (Array.isArray(last.content)) {
+    return last.content.filter(c => c && c.type === 'text').map(c => c.text || '').join(' ');
+  }
+  return '';
+}
+
+function looksLikeCode(messages) {
+  const text = lastUserText(messages);
+  if (!text) return false;
+  if (text.includes('```')) return true;
+
+  const hasKeyword = [...CODE_KEYWORDS].some(kw => new RegExp(`\\b${kw}\\b`).test(text));
+
+  // Считаем операторы/символы; стрелку `=>` учитываем как отдельный символ,
+  // чтобы `=` и `>` внутри неё не задваивались.
+  let symbolCount = 0;
+  const rest = text.replace(/=>/g, '');
+  if (text.includes('=>')) symbolCount += 1;
+  for (const ch of CODE_SYMBOLS) {
+    if (ch === '=>') continue;
+    symbolCount += rest.split(ch).length - 1;
+  }
+
+  if (hasKeyword && symbolCount >= 1) return true;
+  if (symbolCount >= 3) return true;
+  return false;
+}
+
+function normalizeMessages(messages) {
+  if (!Array.isArray(messages)) return '';
+  const userOnly = messages.filter(m => m && m.role === 'user');
+  if (looksLikeCode(messages)) {
+    // Код: точное совпадение, чтобы операторы не схлопывались в один ключ.
+    return JSON.stringify(userOnly);
+  }
+  const userTexts = userOnly
+    .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);
+}
+
+function normalizeText(text) {
+  return (text || '')
+    .toLowerCase()
+    .replace(/[\p{P}\p{S}]+/gu, ' ')   // пунктуация и символы → пробел
+    .replace(/\s+/g, ' ')               // сжать пробелы
+    .trim()
+    .slice(0, MAX_LEN);
+}
+
+module.exports = { normalizeMessages, normalizeText, looksLikeCode, MAX_LEN };

package/lib/providers.js

@@ -69,7 +69,7 @@ for (const [key, provider] of Object.entries(PROVIDERS)) {
   const derivedVar = `PROVIDER_${key.toUpperCase().replace(/-/g, '_')}_APIKEY`;
   const prefix = key.split('-')[0].toUpperCase();
   // Map known prefixes to their real env vars
-  const prefixMap = { OR: 'OPENROUTER', NIM: 'NIM', GROQ: 'GROQ', MISTRAL: 'MISTRAL', GEMINI: 'GEMINI', ZAI: 'ZAI' };
+  const prefixMap = { OR: 'OPENROUTER', NIM: 'NIM', GROQ: 'GROQ', MISTRAL: 'MISTRAL', GEMINI: 'GEMINI', ZAI: 'ZAI', HF: 'HF' };
   const resolvedPrefix = prefixMap[prefix] || prefix;
   const envKey = process.env[explicitVar] || process.env[derivedVar] || process.env[`PROVIDER_${resolvedPrefix}_APIKEY`];
   if (envKey) provider.apiKey = envKey;

package/lib/routing.js

@@ -0,0 +1,60 @@
+// Классификация сложности запроса. Возвращает 0..1.
+// Признаки кода: ключевые слова, символы, длина сообщения, спец-слова.
+// Внимание: \b в JS учитывает только ASCII-символы, поэтому для русских
+// основ (словоформы склоняются: «функцию», «сортировки») используется
+// префиксное совпадение без границ слова, а для латинских слов — \b.
+const CODE_WORDS_EN = /\b(?:function|class|const|let|var|import|export|return|await|async|def|int|void|throw|try|catch|code)\b/gi;
+const CODE_WORDS_RU = /(?:функци|сортировк|массив|код|переменн|цикл|класс|скрипт|комментари)/gi;
+const CODE_SYMBOLS = /[{}\[\]]|=>/;
+const FIX_WORDS = /(?:ошибк|баг|не работает|рефакторинг|исправь|почини|оптимизир)|\b(?:fix|bug|error|exception|refactor|debug)\b/i;
+const REASONING_WORDS = /(?:объясни|почему|зачем|проанализируй|сравни|докажи|спроектируй|архитектур)/i;
+
+const CODE_MATCH_WEIGHT = 0.15;
+const CODE_MATCH_MAX = 0.6;
+
+function classifyComplexity(messages) {
+  if (!Array.isArray(messages)) return 0;
+  // Берем только последнее пользовательское сообщение
+  const last = [...messages].reverse().find(m => m && m.role === 'user');
+  if (!last) return 0;
+  let text = '';
+  if (typeof last.content === 'string') text = last.content;
+  else if (Array.isArray(last.content)) {
+    text = last.content.filter(c => c && c.type === 'text').map(c => c.text || '').join(' ');
+  }
+  text = (text || '').trim();
+  if (text.length === 0) return 0;
+
+  let score = 0;
+  // 1. Длина — длинные запросы сложнее (до +0.3)
+  score += Math.min(text.length / 2000, 0.3);
+  // 2. Код-признаки (до +0.6)
+  let codeMatches = (text.match(CODE_WORDS_EN) || []).length;
+  codeMatches += (text.match(CODE_WORDS_RU) || []).length;
+  if (CODE_SYMBOLS.test(text)) codeMatches += 1;
+  score += Math.min(codeMatches * CODE_MATCH_WEIGHT, CODE_MATCH_MAX);
+  // 3. Слова об исправлении/ошибках (до +0.2)
+  if (FIX_WORDS.test(text)) score += 0.2;
+  // 4. Слова о рассуждениях (до +0.2)
+  if (REASONING_WORDS.test(text)) score += 0.2;
+  // 5. Наличие блоков кода ``` (до +0.2)
+  if ((text.match(/```/g) || []).length >= 2) score += 0.2;
+  return Math.min(score, 1);
+}
+
+// Поднятие тира при высокой сложности. Простые остаются на месте.
+const UPGRADE_MAP = {
+  'tier-s': 'tier-splus',  // лёгкий → мощный (ox-alpha reasoning)
+  'tier-a': 'tier-s',      // лёгкий → быстрый
+  'tier-b': 'tier-s',      // лёгкий → быстрый
+};
+const COMPLEX_THRESHOLD = 0.5;
+
+function maybeUpgradeTier(requestedModel, complexity) {
+  if (complexity >= COMPLEX_THRESHOLD && UPGRADE_MAP[requestedModel]) {
+    return UPGRADE_MAP[requestedModel];
+  }
+  return requestedModel;
+}
+
+module.exports = { classifyComplexity, maybeUpgradeTier, COMPLEX_THRESHOLD };

package/package.json

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

package/server.js

@@ -9,6 +9,7 @@ const { checkRateLimit } = require('./lib/rateLimit');
 const { handleDashboard } = require('./lib/dashboard');
 const { acquire, stats: poolStats } = require('./lib/pool');
 const { stripThink, cleanDelta, cleanMessage, fixReasoningMessage } = require('./lib/clean');
+const { classifyComplexity, maybeUpgradeTier } = require('./lib/routing');
 const logger = require('./lib/logger');
 
 // Load persisted state
@@ -24,7 +25,7 @@ if (stale.length > 0) {
   logger.info('Cleaned stale health entries', { removed: stale });
 }
 
-const cache = new LRUCache(500, 3600000);
+const cache = new LRUCache(500, 3600000, false, true); // 4th arg: semantic normalize ON
 require('./lib/cache')._activeCache = cache;
 
 // Load config (with fallback so a corrupt config never crashes the server)
@@ -120,7 +121,10 @@ setTimeout(healthCheck, 1000);
 // Chat completion handler
 async function handleChatCompletion(req, res, body) {
   const requestedModel = body.model || 'tier-splus';
-  let targetProviderKey = MODEL_MAP[requestedModel] || 'zai';
+  // Умный роутинг: сложные задачи с лёгкого тира поднимаем на более мощный.
+  // Классифицируем ПОСЛЕ того, как определён requestedModel, ДО выбора провайдера.
+  const effectiveModel = maybeUpgradeTier(requestedModel, classifyComplexity(body.messages));
+  let targetProviderKey = MODEL_MAP[effectiveModel] || MODEL_MAP[requestedModel] || 'zai';
   const isStreaming = body.stream === true;
 
   // Vision detection: if the request contains images, route to a vision provider.
@@ -205,7 +209,7 @@ async function handleChatCompletion(req, res, body) {
   }
 
   // Check cache (works for both streaming and non-streaming)
-  const cached = cache.get(requestedModel, body.messages, body.temperature);
+  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 });
@@ -387,7 +391,7 @@ async function handleChatCompletion(req, res, body) {
           // Cache the assembled answer for repeat prompts (only if complete)
           if (chunks.length > 0) {
             const full = chunks.join('');
-            cache.set(requestedModel, body.messages, body.temperature, {
+            cache.set(effectiveModel, body.messages, body.temperature, {
               id: 'chatcmpl-cached',
               object: 'chat.completion',
               created: Math.floor(Date.now() / 1000),
@@ -411,7 +415,7 @@ async function handleChatCompletion(req, res, body) {
             fixReasoningMessage(result.data.choices[0].message);
             cleanMessage(result.data.choices[0].message);
           }
-        cache.set(requestedModel, body.messages, body.temperature, result.data);
+        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));
@@ -472,7 +476,7 @@ async function handleChatCompletion(req, res, body) {
           fixReasoningMessage(result.data.choices[0].message);
           cleanMessage(result.data.choices[0].message);
         }
-          cache.set(requestedModel, body.messages, body.temperature, result.data);
+          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));