freegate 0.6.15 → 0.6.16

package/lib/modelmanager.js

@@ -0,0 +1,335 @@
+// lib/modelmanager.js — оркестратор самообновляющейся базы моделей.
+// Цикл: seed каталога → проверка существующих → перепроверка мёртвых (старше N
+// дней) → скан источников → параллельный тест новых → добавление рабочих →
+// скор → write-back priority (только auto-managed ключи) → hot-reload.
+// Single-flight: циклы не перекрываются. Никогда не бросает исключений наружу.
+
+const fs = require('fs');
+const { ModelDB, computeScore } = require('./modeldb');
+const modelscan = require('./modelscan');
+
+const DEFAULTS = {
+  enabled: true,
+  intervalHours: 6,
+  autoAdd: true,
+  maxTestParallel: 5,
+  maxTestPerCycle: 80,
+  recheckDisabledDays: 7,
+  testTimeoutMs: 20000,
+};
+
+function readJsonSafe(path) {
+  try { return JSON.parse(fs.readFileSync(path, 'utf8')); } catch { return {}; }
+}
+
+function inferSource(providerEntry) {
+  const env = providerEntry.envVar || '';
+  if (env.includes('OPENROUTER')) return 'openrouter';
+  if (env.includes('HF')) return 'huggingface';
+  const ep = providerEntry.endpoint || '';
+  if (ep.includes('api.groq.com')) return 'groq';
+  if (ep.includes('api.mistral.ai')) return 'mistral';
+  if (ep.includes('generativelanguage')) return 'gemini';
+  if (ep.includes('api.cerebras.ai')) return 'cerebras';
+  if (ep.includes('api.deepseek.com')) return 'deepseek';
+  if (ep.includes('integrate.api.nvidia')) return 'nim';
+  return 'unknown';
+}
+
+function keyFor(source, model) {
+  const prefixMap = { openrouter: 'or-', huggingface: 'hf-' };
+  const prefix = prefixMap[source] || source + '-';
+  return prefix + String(model).split('/').pop().replace(/[:.]/g, '-').slice(0, 30);
+}
+
+// Гарантированно-бесплатная ли модель для автодобавления.
+// :free (OpenRouter) — всегда. Нatивные источники — только известные бесплатные
+// семейства; иначе риск добавить платную модель, на которой авто-тест прошёл
+// (mistral-medium, deepseek-v4-pro, GLM-5.2), и она попадёт в роутинг.
+// Источники с большим лимитом (groq/cerebras/gemini) реально бесплатны — там
+// семейства допустимы. Источники с малым лимитом и платными рядами (hf/nim)
+// — только явно безопасные free-семейства (gemma/qwen/llama/nano/ministral).
+function isAutoAddable(candidate) {
+  const model = String(candidate.model || '');
+  if (model.includes(':free')) return true;
+  const source = candidate.source;
+  // Явно платные модели — никогда (даже если авто-тест прошёл на балансе).
+  if (/(mistral-medium|mistral-large|magistral|deepseek-v4-pro|GLM-5\.|-v4-pro\b)/i.test(model)) return false;
+  if (['groq', 'cerebras', 'gemini'].includes(source)) {
+    return /(qwen|llama|gemma|gpt-oss|nemotron|mini|compound)/i.test(model);
+  }
+  if (source === 'nim') {
+    // NIM — стабильно бесплатный тариф: какие-то из этих семейств по free.
+    return /(nemotron|llama|kimi|minimax|laguna|gemma|qwen|deepseek)/i.test(model);
+  }
+  // hf и прочие осторожные — только проверенные free-семейства
+  return /(gemma|qwen|llama-3\.1|ministral|nano)/i.test(model);
+}
+
+class ModelManager {
+  constructor({ dbPath, catalogPath, configPath, keys = {}, fetchImpl, config = {}, reload = null, now = () => Date.now(), log = () => {} }) {
+    this.dbPath = dbPath;
+    this.catalogPath = catalogPath;
+    this.configPath = configPath;
+    this.keys = keys;
+    this.fetchImpl = fetchImpl;
+    this.config = { ...DEFAULTS, ...config };
+    this.reload = reload;
+    this.now = now;
+    this.log = log;
+    this.db = new ModelDB(dbPath);
+    this.db.load();
+    this._running = false;
+  }
+
+  // Наполнение db из providers.json (idempotent: только отсутствующие ключи).
+  // enabled:false в config.json = выбор пользователя → статус user-disabled,
+  // такие никогда не перепроверяются и не реактивируются автоматически.
+  seed() {
+    const catalog = readJsonSafe(this.catalogPath);
+    const userCfg = readJsonSafe(this.configPath);
+    let added = 0;
+    for (const [key, p] of Object.entries(catalog)) {
+      if (!p || !p.model || !p.endpoint) continue;
+      if (this.db.get(key)) continue;
+      const userDisabled = userCfg.providers?.[key]?.enabled === false;
+      this.db.upsert({
+        key,
+        model: p.model,
+        endpoint: p.endpoint,
+        source: inferSource(p),
+        category: p.category || modelscan.classifyModel(p.model),
+        contextWindow: p.context_window || 0,
+        dailyLimit: p.dailyLimit || 0,
+        status: userDisabled ? 'user-disabled' : 'untested',
+        seeded: true,
+      });
+      added++;
+    }
+    if (added > 0) this.db.save();
+    return added;
+  }
+
+  apiKeyFor(source) {
+    return this.keys[source] || process.env[modelscan.SOURCE_META[source]?.envVar] || '';
+  }
+
+  // 1. Проверка активных/untested моделей. dead (404/402) → enabled:false в конфиге.
+  async checkExisting() {
+    let checked = 0, disabledNow = 0, configChanged = false;
+    const userCfg = readJsonSafe(this.configPath);
+    for (const m of this.db.all()) {
+      if (m.status !== 'active' && m.status !== 'untested') continue;
+      const test = await modelscan.testModel(m.endpoint, m.model, this.apiKeyFor(m.source), { timeout: this.config.testTimeoutMs, fetchImpl: this.fetchImpl });
+      const before = m.status;
+      this.db.markChecked(m.key, test, { now: this.now() });
+      checked++;
+      if (before !== 'dead' && this.db.get(m.key).status === 'dead') {
+        if (!userCfg.providers) userCfg.providers = {};
+        userCfg.providers[m.key] = { ...(userCfg.providers[m.key] || {}), enabled: false };
+        configChanged = true;
+        disabledNow++;
+        this.log(`  ❌ ${m.key} (${m.model}): ${test.status} — отключаю`);
+      }
+    }
+    if (configChanged) fs.writeFileSync(this.configPath, JSON.stringify(userCfg, null, 2));
+    return { checked, disabledNow, configChanged };
+  }
+
+  // 2. Перепроверка мёртвых старше recheckDisabledDays. Ожил → active + enabled:true.
+  async recheckDisabled() {
+    let rechecked = 0, reenabled = 0, configChanged = false;
+    const cutoff = this.config.recheckDisabledDays * 86400000;
+    const now = this.now();
+    const userCfg = readJsonSafe(this.configPath);
+    for (const m of this.db.all()) {
+      if (m.status !== 'dead') continue;
+      if (!m.lastCheckedAt || now - m.lastCheckedAt < cutoff) continue;
+      rechecked++;
+      const test = await modelscan.testModel(m.endpoint, m.model, this.apiKeyFor(m.source), { timeout: this.config.testTimeoutMs, fetchImpl: this.fetchImpl });
+      this.db.markChecked(m.key, test, { now: this.now() });
+      if (test.ok) {
+        if (!userCfg.providers) userCfg.providers = {};
+        userCfg.providers[m.key] = { ...(userCfg.providers[m.key] || {}), enabled: true };
+        configChanged = true;
+        reenabled++;
+        this.log(`  ♻️ ${m.key}: ожил — реактивирован`);
+      }
+    }
+    if (configChanged) fs.writeFileSync(this.configPath, JSON.stringify(userCfg, null, 2));
+    return { rechecked, reenabled, configChanged };
+  }
+
+  // 3. Скан новых + параллельный тест + добавление рабочих.
+  async scanAndAdd() {
+    const catalog = readJsonSafe(this.catalogPath);
+    const existing = new Set(Object.values(catalog).map(p => p.model));
+    for (const m of this.db.all()) existing.add(m.model);
+
+    const candidates = await modelscan.scanSources({
+      keys: this.keys, fetchImpl: this.fetchImpl, existing, log: this.log,
+    });
+    let added = 0, catalogChanged = false;
+    if (candidates.length === 0) return { scanned: 0, tested: 0, added, catalogChanged };
+
+    if (!this.config.autoAdd) {
+      this.log(`  ⏭ AUTO_ADD=false — ${candidates.length} кандидатов не тестирую`);
+      return { scanned: candidates.length, tested: 0, added, catalogChanged };
+    }
+
+    // Кап тестов за цикл: не жжём лимиты, если источник отдал сотни кандидатов.
+    // Сначала тестируем гарантированно-бесплатных (:free), затем остальных.
+    const freeFirst = [...candidates].sort((a, b) =>
+      ((b.model.includes(':free') ? 1 : 0) - (a.model.includes(':free') ? 1 : 0)));
+    const toTest = freeFirst.slice(0, this.config.maxTestPerCycle);
+    const tested = await modelscan.testCandidates(toTest, {
+      keys: this.keys, fetchImpl: this.fetchImpl,
+      concurrency: this.config.maxTestParallel, timeout: this.config.testTimeoutMs, log: this.log,
+    });
+    for (const c of tested) {
+      if (!c.test.ok) continue; // 429/сбой — не добавляем
+      // Анти-мусор: автодобавляем только гарантированно-бесплатные модели.
+      // OpenRouter — только :free. Остальные источники (groq/cerebras/gemini/
+      // nim/hf) — только если мы уже знаем модель как бесплатную (есть в
+      // исходном каталоге/белом списке) или это явно free. Иначе не добавляем:
+      // авто-тест может пройти на платной модели и она попадёт в роутинг.
+      if (!isAutoAddable(c)) {
+        this.log(`  ⏭ ${c.model}: не бесплатная — пропуск (report-only)`);
+        continue;
+      }
+      const key = keyFor(c.source, c.model);
+      this.db.upsert({
+        key, model: c.model, endpoint: c.endpoint, source: c.source,
+        category: c.category || modelscan.classifyModel(c.model),
+        contextWindow: c.contextWindow || 0, dailyLimit: c.dailyLimit || 0,
+        meta: c.meta || {},
+      });
+      this.db.markChecked(key, c.test, { now: this.now() });
+      catalog[key] = {
+        endpoint: c.endpoint,
+        model: c.model,
+        priority: 99, // writeBackPriorities проставит ранг по скору
+        dailyLimit: c.dailyLimit || 0,
+        keyHint: `${c.source} → Keys (автодобавлено, ${c.category})`,
+        envVar: modelscan.SOURCE_META[c.source]?.envVar || '',
+        free: true,
+        category: c.category || 'general',
+      };
+      added++;
+      catalogChanged = true;
+    }
+    if (catalogChanged) {
+      fs.writeFileSync(this.catalogPath, JSON.stringify(catalog, null, 2) + '\n');
+    }
+    return { scanned: candidates.length, tested: tested.length, added, catalogChanged };
+  }
+
+  // 4. Скор по истории проверок (successRate + латентность + окно + свежесть).
+  updateScores() {
+    const now = this.now();
+    for (const m of this.db.all()) {
+      const history = m.checkHistory || [];
+      let successRate = 0.5;
+      if (history.length > 0) {
+        successRate = history.filter(h => h.ok).length / history.length;
+      }
+      const okLat = history.filter(h => h.ok && h.latencyMs > 0);
+      const latencyEma = okLat.length > 0
+        ? okLat.reduce((a, h) => a + h.latencyMs, 0) / okLat.length
+        : 0;
+      m.score = computeScore({ successRate, latencyEma, contextWindow: m.contextWindow, lastOkAt: m.lastOkAt, now });
+    }
+  }
+
+  // 5. Priority write-back: только auto-managed ключи (не seeded). Ранг в
+    // категории по скору (1 = лучший). Ручные записи каталога не трогаем.
+  writeBackPriorities() {
+    const catalog = readJsonSafe(this.catalogPath);
+    const byCategory = {};
+    for (const m of this.db.all()) {
+      if (m.seeded) continue;
+      if (!catalog[m.key]) continue;
+      (byCategory[m.category] || (byCategory[m.category] = [])).push(m);
+    }
+    let changed = false;
+    for (const entries of Object.values(byCategory)) {
+      entries.sort((a, b) => (b.score || 0) - (a.score || 0));
+      entries.forEach((m, i) => {
+        const p = i + 1;
+        if (catalog[m.key].priority !== p) {
+          catalog[m.key].priority = p;
+          changed = true;
+        }
+      });
+    }
+    if (changed) fs.writeFileSync(this.catalogPath, JSON.stringify(catalog, null, 2) + '\n');
+    return changed;
+  }
+
+  // Полный цикл. Single-flight.
+  async runCycle() {
+    if (this._running) return { skipped: true };
+    this._running = true;
+    try {
+      const summary = { checkedExisting: 0, disabledNow: 0, rechecked: 0, reenabled: 0, scanned: 0, tested: 0, added: 0, priorityUpdated: false };
+      this.seed();
+
+      const ex = await this.checkExisting();
+      summary.checkedExisting = ex.checked;
+      summary.disabledNow = ex.disabledNow;
+
+      const rc = await this.recheckDisabled();
+      summary.rechecked = rc.rechecked;
+      summary.reenabled = rc.reenabled;
+
+      const sa = await this.scanAndAdd();
+      summary.scanned = sa.scanned;
+      summary.tested = sa.tested;
+      summary.added = sa.added;
+
+      this.updateScores();
+      this.db.save();
+
+      const prioritiesChanged = this.writeBackPriorities();
+      summary.priorityUpdated = prioritiesChanged;
+
+      const catalogChanged = sa.catalogChanged || prioritiesChanged;
+      if (catalogChanged || rc.configChanged || ex.configChanged) {
+        if (this.reload) {
+          try { this.reload(); } catch {}
+        }
+      }
+      return summary;
+    } catch (err) {
+      this.log(`  цикл прерван: ${err.message}`);
+      return { error: err.message };
+    } finally {
+      this._running = false;
+    }
+  }
+
+  // «Всегда»: стартовый отложенный прогон + интервал с джиттером.
+  start() {
+    if (!this.config.enabled) return null;
+    const jitter = (min, max) => min + Math.random() * (max - min);
+    const intervalMs = this.config.intervalHours * 3600000;
+    this._timer = setInterval(() => {
+      this.runCycle().catch(() => {});
+    }, intervalMs + jitter(-600000, 600000)); // ±10 мин джиттер
+    this._timer.unref?.();
+    // Первый прогон через 2 минуты после старта (пусть сервер поднимется).
+    this._initial = setTimeout(() => {
+      this.runCycle().catch(() => {});
+    }, 120000);
+    this._initial.unref?.();
+    return this;
+  }
+
+  stop() {
+    if (this._timer) clearInterval(this._timer);
+    if (this._initial) clearTimeout(this._initial);
+    this._timer = this._initial = null;
+  }
+}
+
+module.exports = { ModelManager, keyFor, inferSource, isAutoAddable, DEFAULTS };

package/lib/modelscan.js

@@ -0,0 +1,190 @@
+// lib/modelscan.js — многоисточниковый сканер бесплатных моделей для Freegate.
+// Каждый источник — адаптер, отдающий нормализованных кандидатов:
+// { model, source, endpoint, contextWindow, dailyLimit, category }.
+// Вся сеть через injectable fetchImpl — юнит-тесты ходят в моки, не в сеть.
+
+// Источники для автопоиска. Исключены mistral/deepseek: их каталог включает
+// платные модели, и авто-тест может «пройти» на платной модели, после чего
+// она попадает в роутинг и жжёт деньги/ломается. Надёжно-бесплатные: openrouter
+// (только :free), groq, cerebras, gemini (free tier), nim (малый лимит, но
+// стабильно бесплатный), huggingface. Каталог расширяется вручную через
+// config.json/providers.json.
+const SOURCES = ['openrouter', 'huggingface', 'groq', 'gemini', 'cerebras', 'nim'];
+
+// Endpoints списков моделей и chat-completions по источникам.
+const SOURCE_META = {
+  openrouter: { list: 'https://openrouter.ai/api/v1/models', chat: 'https://openrouter.ai/api/v1/chat/completions', envVar: 'PROVIDER_OPENROUTER_APIKEY', dailyLimit: 50 },
+  huggingface: { list: 'https://router.huggingface.co/v1/models', chat: 'https://router.huggingface.co/v1/chat/completions', envVar: 'PROVIDER_HF_APIKEY', dailyLimit: 200 },
+  groq: { list: 'https://api.groq.com/openai/v1/models', chat: 'https://api.groq.com/openai/v1/chat/completions', envVar: 'PROVIDER_GROQ_APIKEY', dailyLimit: 1000 },
+  mistral: { list: 'https://api.mistral.ai/v1/models', chat: 'https://api.mistral.ai/v1/chat/completions', envVar: 'PROVIDER_MISTRAL_APIKEY', dailyLimit: 500 },
+  gemini: { list: 'https://generativelanguage.googleapis.com/v1beta/openai/models', chat: 'https://generativelanguage.googleapis.com/v1beta/openai/chat/completions', envVar: 'PROVIDER_GEMINI_APIKEY', dailyLimit: 1500 },
+  cerebras: { list: 'https://api.cerebras.ai/v1/models', chat: 'https://api.cerebras.ai/v1/chat/completions', envVar: 'PROVIDER_CEREBRAS_APIKEY', dailyLimit: 1000 },
+  deepseek: { list: 'https://api.deepseek.com/models', chat: 'https://api.deepseek.com/chat/completions', envVar: 'PROVIDER_DEEPSEEK_APIKEY', dailyLimit: 1000 },
+  nim: { list: 'https://integrate.api.nvidia.com/v1/models', chat: 'https://integrate.api.nvidia.com/v1/chat/completions', envVar: 'PROVIDER_NIM_APIKEY', dailyLimit: 40 },
+};
+
+// Мусор: эмбеддинги, реранки, аудио/речь/музыка, guardrail, картинки/видео,
+// робототехника, computer-use, калибровки. Всё, что не plain-chat.
+const JUNK_RE = /embed|rerank|whisper|tts|audio|transcrib|speech|riva|lyria|guard|safety|moder|diffusion|stable-|\/sd[-_]|flux|image|img|banana|veo|imagen|robot|computer-use|calibrat|bert|clip\b|live|realtime|dubbing/i;
+// HF: только известные chat-семейства (иначе сотни нерелевантных репо).
+const HF_FAMILY_RE = /(qwen|llama|glm|gemma|mistral|deepseek|nemotron|gpt-oss|phi|command|aya|falcon|olmo)/i;
+
+function isJunkModel(id) {
+  if (!id) return true;
+  return JUNK_RE.test(id);
+}
+
+// Gemini отдаёт id с префиксом 'models/' — нормализуем (OpenAI-compat endpoint
+// принимает id без префикса, и это же устраняет ложный dedup с каталогом).
+function normalizeModelId(id, source) {
+  let out = String(id || '');
+  if (source === 'gemini') out = out.replace(/^models\//, '');
+  return out;
+}
+
+// Категория по id/описанию: vision > coding > reasoning > general.
+function classifyModel(id, desc = '') {
+  const m = String(id || '').toLowerCase();
+  const d = String(desc || '').toLowerCase();
+  if (/-vl\b|vision|omni|multimodal/.test(m) || /image input|multimodal/.test(d)) return 'vision';
+  if (/codestral|coder|code\b|devstral|starcoder/.test(m) || /coding/.test(d)) return 'coding';
+  if (/r1\b|qwq|think|reason/.test(m) || /reasoning|agentic/.test(d)) return 'reasoning';
+  return 'general';
+}
+
+function fetchModelsList(url, apiKey, fetchImpl, timeout = 15000) {
+  return fetchImpl(url, {
+    headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+    signal: AbortSignal.timeout(timeout),
+  });
+}
+
+// Адаптеры: list-ответ ({data:[{id, context_length?, description?}]}) → кандидаты.
+const ADAPTERS = {
+  openrouter: async (ctx) => {
+    const res = await fetchModelsList(SOURCE_META.openrouter.list, '', ctx.fetch);
+    if (!res.ok) return [];
+    const data = await res.json().catch(() => ({}));
+    const out = [];
+    for (const m of (data.data || [])) {
+      const id = normalizeModelId(m.id, 'openrouter');
+      if (!id || !id.endsWith(':free')) continue;
+      if (ctx.existing.has(id) || isJunkModel(id)) continue;
+      out.push({
+        model: id, source: 'openrouter', endpoint: SOURCE_META.openrouter.chat,
+        contextWindow: m.context_length || 0, dailyLimit: SOURCE_META.openrouter.dailyLimit,
+        category: classifyModel(id, m.description || ''), meta: { description: (m.description || '').slice(0, 200) },
+      });
+    }
+    return out;
+  },
+
+  huggingface: async (ctx) => {
+    const key = ctx.keys.huggingface || '';
+    if (!key) return [];
+    const res = await fetchModelsList(SOURCE_META.huggingface.list, key, ctx.fetch);
+    if (!res.ok) return [];
+    const data = await res.json().catch(() => ({}));
+    const out = [];
+    for (const m of (data.data || [])) {
+      const id = normalizeModelId(m.id, 'huggingface');
+      if (!id || ctx.existing.has(id) || isJunkModel(id)) continue;
+      if (!HF_FAMILY_RE.test(id)) continue;
+      out.push({
+        model: id, source: 'huggingface', endpoint: SOURCE_META.huggingface.chat,
+        contextWindow: m.context_length || 0, dailyLimit: SOURCE_META.huggingface.dailyLimit,
+        category: classifyModel(id),
+      });
+    }
+    return out;
+  },
+};
+
+// Нативные OpenAI-совместимые списки: один паттерн на все источники.
+for (const name of ['groq', 'mistral', 'gemini', 'cerebras', 'deepseek', 'nim']) {
+  ADAPTERS[name] = async (ctx) => {
+    const meta = SOURCE_META[name];
+    const key = ctx.keys[name] || process.env[meta.envVar] || '';
+    if (!key) return [];
+    const res = await fetchModelsList(meta.list, key, ctx.fetch);
+    if (!res.ok) return [];
+    const data = await res.json().catch(() => ({}));
+    const out = [];
+    for (const m of (data.data || [])) {
+      const id = normalizeModelId(typeof m === 'string' ? m : m.id, name);
+      if (!id || ctx.existing.has(id) || isJunkModel(id)) continue;
+      out.push({
+        model: id, source: name, endpoint: meta.chat,
+        contextWindow: (typeof m === 'object' && m.context_length) || 0,
+        dailyLimit: meta.dailyLimit,
+        category: classifyModel(id),
+      });
+    }
+    return out;
+  };
+}
+
+// Скан источников: кандидаты, dedup по model id (первый источник в списке выигрывает).
+async function scanSources({ sources = SOURCES, keys = {}, fetchImpl, existing = new Set(), log = () => {} } = {}) {
+  if (!fetchImpl) throw new Error('modelscan: fetchImpl is required');
+  const seen = new Set(existing);
+  const out = [];
+  for (const name of sources) {
+    const adapter = ADAPTERS[name];
+    if (!adapter) continue;
+    try {
+      const candidates = await adapter({ keys, fetch: fetchImpl, existing: seen });
+      let fresh = 0;
+      for (const c of candidates) {
+        if (seen.has(c.model)) continue; // dedup между источниками
+        seen.add(c.model);
+        out.push(c);
+        fresh++;
+      }
+      if (fresh > 0) log(`  ${name}: ${fresh} новых кандидатов`);
+    } catch (e) {
+      log(`  ${name}: ошибка скана — ${e.message}`);
+    }
+  }
+  return out;
+}
+
+// Реальный тест модели: chat/completions "hi", max_tokens 5. HTTP 200 = жива.
+async function testModel(endpoint, model, apiKey, { timeout = 20000, fetchImpl } = {}) {
+  const t0 = Date.now();
+  try {
+    const res = await fetchImpl(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(timeout),
+    });
+    if (!res.ok) return { ok: false, status: res.status, latencyMs: Date.now() - t0 };
+    await res.json().catch(() => {});
+    return { ok: true, status: res.status, latencyMs: Date.now() - t0 };
+  } catch {
+    return { ok: false, status: 0, latencyMs: Date.now() - t0 };
+  }
+}
+
+// Параллельный тест кандидатов с ограничением одновременности (worker pool).
+async function testCandidates(candidates, { keys = {}, fetchImpl, concurrency = 5, timeout = 20000, log = () => {} } = {}) {
+  if (!fetchImpl) throw new Error('modelscan: fetchImpl is required');
+  if (!Array.isArray(candidates) || candidates.length === 0) return [];
+  const results = [];
+  let idx = 0;
+  async function worker() {
+    while (idx < candidates.length) {
+      const c = candidates[idx++];
+      const apiKey = keys[c.source] || process.env[SOURCE_META[c.source]?.envVar] || '';
+      const test = await testModel(c.endpoint, c.model, apiKey, { timeout, fetchImpl });
+      if (test.ok) log(`  ✅ ${c.model} (${c.category})`);
+      else if (test.status === 429) log(`  ⏳ ${c.model}: 429 (лимит)`);
+      results.push({ ...c, test });
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(concurrency, candidates.length) }, worker));
+  return results;
+}
+
+module.exports = { SOURCES, SOURCE_META, ADAPTERS, isJunkModel, classifyModel, normalizeModelId, scanSources, testModel, testCandidates };

package/lib/normalize.js

@@ -2,6 +2,9 @@
 // Сравниваются только пользовательские текстовые сообщения, без system.
 
 const MAX_LEN = 2000;
+const TAIL_LEN = 400; // последние N символов диалога — всегда в ключе, чтобы
+                 // два диалога с общим длинным префиксом не схлопывались
+                 // в один кэш-ключ (иначе кэш отдаёт ответ из чужого чата).
 
 const CODE_SYMBOLS = new Set(['{', '}', '[', ']', '=>', ';', '=', '+', '-', '*', '/', '<', '>']);
 const CODE_KEYWORDS = new Set([
@@ -78,12 +81,19 @@ function normalizeMessages(messages) {
 }
 
 function normalizeText(text) {
-  return (text || '')
+  const cleaned = (text || '')
     .toLowerCase()
     .replace(/[\p{P}\p{S}]+/gu, ' ')   // пунктуация и символы → пробел
     .replace(/\s+/g, ' ')               // сжать пробелы
-    .trim()
-    .slice(0, MAX_LEN);
+    .trim();
+  // Хэш-ключ = начало (первые MAX_LEN) + конец (последние TAIL_LEN).
+  // Если просто обрезать до MAX_LEN, два длинных диалога с одинаковым
+  // префиксом совпадут — кэш отдаст ответ из чужого чата. Хвост диалога
+  // (последние сообщения) почти всегда различает их.
+  const tail = cleaned.length > MAX_LEN
+    ? cleaned.slice(-TAIL_LEN)
+    : '';
+  return cleaned.slice(0, MAX_LEN) + tail;
 }
 
-module.exports = { normalizeMessages, normalizeText, looksLikeCode, MAX_LEN };
+module.exports = { normalizeMessages, normalizeText, looksLikeCode, MAX_LEN, TAIL_LEN };