freegate 0.6.15 → 0.6.17

package/lib/compactor.js

@@ -0,0 +1,220 @@
+// lib/compactor.js
+// Detects when a conversation exceeds the context window of free models and
+// compresses old messages into a single summary via a long-context model.
+// Zero deps: pure Node built-ins + existing callProvider/lib.
+
+const crypto = require('crypto');
+const path = require('path');
+const { PROVIDERS, callProvider } = require('./providers');
+
+const COMPACT_THRESHOLD = 60000;  // tokens — compact above 60k. estimateTokens intentionally
+                                  // UNDERCOUNTS (only text content we can see), while opencode's
+                                  // session counter includes cache/role tokens + huge system prompt.
+                                  // Empirically opencode reads ~2x our estimate on real sessions,
+                                  // so 60k est ≈ 120-160k real — safely below free-model windows
+                                  // while keeping context summaries fresh.
+const KEEP_RECENT_TOKENS = 30000; // tokens — recent messages kept untouched (preserve session context)
+const MAX_COMPACT_THRESHOLD = 100000; // est tokens — cap for window-aware thresholds (≈200k real,
+                                      // sits safely inside even 512k/1M windows without compacting too early)
+const SUMMARY_MAX_TOKENS = 2000;  // tokens — summary length cap (detailed enough to not lose the work)
+const CHARS_PER_TOKEN = 1.5;      // heuristic chars→tokens, DOUBLY conservative: real sessions
+                                  // (with tool outputs, files, big system prompts) average ~0.75
+                                  // chars/token, not ~4. Using 1.5 keeps us from compacting too late.
+
+// Reliability-ordered long-context summarizers (OpenRouter + HF).
+const SUMMARIZERS = [
+  'or-nemotron-35', 'or-dots-3', 'or-minimax-m2-7-free',
+  'or-lfm', 'deepseek',
+];
+
+// Summary cache: hash of compacted messages → summary string.
+// In-memory only (like the main cache) — survives across requests, not restarts.
+const summaryCache = new Map();
+const SUMMARY_CACHE_MAX = 300;
+
+// --- Долговременная память (vector memory) ---
+// Компактор извлекает факты попутно с резюме — НЕ добавляя ни одного лишнего
+// LLM-вызова. Память инжектируется из server.js (setMemory), чтобы не заводить
+// жёсткую связанность между модулями.
+let memoryStore = null;
+const MAX_FACTS_PER_COMPACTION = 5;
+
+function setMemory(store) {
+  memoryStore = store;
+}
+
+// Summarizer запрашивается вернуть JSON вида {"summary": "...", "facts": [...]}.
+// Многие модели вернут чистый текст — тогда берём только текст (старое
+// поведение, никаких потерь). Парсим оба варианта + fenced json.
+function parseSummaryResponse(text) {
+  if (!text) return { summary: '', facts: [] };
+  const trimmed = String(text).trim();
+  const attempt = (s) => {
+    try {
+      const obj = JSON.parse(s);
+      if (!obj || typeof obj !== 'object') return null;
+      const summary = typeof obj.summary === 'string' ? obj.summary : '';
+      const facts = Array.isArray(obj.facts)
+        ? obj.facts.filter(f => typeof f === 'string' && f.trim().length > 2)
+        : [];
+      return { summary, facts };
+    } catch { return null; }
+  };
+  let parsed = attempt(trimmed);
+  if (!parsed) {
+    const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fenced) parsed = attempt(fenced[1].trim());
+  }
+  if (parsed) return parsed;
+  return { summary: trimmed, facts: [] };
+}
+
+// Сохранить факты в долговременную память (если она подключена).
+function ingestFacts(facts, sourceHash) {
+  if (!memoryStore || !Array.isArray(facts) || facts.length === 0) return 0;
+  let n = 0;
+  for (const f of facts.slice(0, MAX_FACTS_PER_COMPACTION)) {
+    if (memoryStore.add(f, { sourceHash })) n++;
+  }
+  return n;
+}
+
+// --- Estimate tokens from messages array ---
+// Conservative: counts text + images + tool calls + attachments, and uses a
+// lower chars-per-token ratio so the estimate is closer to real provider usage
+// (which also counts role/formatting tokens). Undercounting means we compact
+// too late and the free models reject the request.
+function estimateTokens(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return 0;
+  let chars = 0;
+  for (const m of messages) {
+    if (!m || typeof m !== 'object') continue;
+    // Tool calls / attachments / function results add a lot.
+    if (Array.isArray(m.tool_calls)) chars += 200 * m.tool_calls.length;
+    if (Array.isArray(m.attachments)) chars += 300 * m.attachments.length;
+    if (Array.isArray(m.file)) chars += 500;
+    if (typeof m.content === 'string') chars += m.content.length;
+    else if (Array.isArray(m.content)) {
+      for (const c of m.content) {
+        if (!c || typeof c !== 'object') continue;
+        if (typeof c.text === 'string') chars += c.text.length;
+        else if (c.image_url && typeof c.image_url === 'object') chars += 800; // images/vision count a lot
+        else if (c.image || c.type === 'image' || c.type === 'input_image') chars += 800;
+      }
+    }
+  }
+  return Math.ceil(chars / CHARS_PER_TOKEN);
+}
+
+// Эффективный порог компакции зависит от реального окна целевого провайдера.
+// estimateTokens намеренно занижает (~2x реальных токенов), поэтому для
+// известного окна держим est <= win*0.5 (реальные токены точно влезут) и
+// капаем на MAX_COMPACT_THRESHOLD — большие окна (512k/1M) не заставляют
+// компактировать раньше необходимости. Неизвестное окно — прежнее поведение.
+function compactionThresholdFor(contextWindow) {
+  if (!contextWindow || contextWindow <= 0) return COMPACT_THRESHOLD;
+  return Math.min(Math.floor(contextWindow * 0.5), MAX_COMPACT_THRESHOLD);
+}
+
+// --- Build the compaction algorithm structure (logic filled in Task 2) ---
+async function prepareMessages(messages, opts = {}) {
+  // Compact if above threshold; otherwise return unchanged.
+  if (!Array.isArray(messages) || messages.length === 0) return messages;
+  const total = estimateTokens(messages);
+  if (total <= compactionThresholdFor(opts.contextWindow)) return messages;
+  return compactOld(messages);
+}
+
+// --- Split messages: recent kept, old summarized ---
+async function compactOld(messages) {
+  // System messages (opencode AGENTS.md, plugin skills) are huge and critical —
+  // NEVER summarize or drop them. Split them off first.
+  const systemMsgs = messages.filter(m => m && m.role === 'system');
+  const rest = messages.filter(m => !m || m.role !== 'system');
+
+  // Walk from the end accumulating tokens until we fill KEEP_RECENT_TOKENS.
+  const recent = [];
+  let recentTokens = 0;
+  for (let i = rest.length - 1; i >= 0; i--) {
+    const m = rest[i];
+    const tokens = estimateTokens([m]);
+    if (recentTokens + tokens > KEEP_RECENT_TOKENS && recent.length > 0) {
+      break;
+    }
+    recent.unshift(m);
+    recentTokens += tokens;
+  }
+  // old = everything before the recent tail (non-system); never summarize system.
+  const old = rest.slice(0, rest.length - recent.length);
+  if (old.length === 0) return messages; // nothing compactable (single huge msg → keep all)
+
+  const summary = await module.exports.getSummary(old);
+  const finalLength = estimateTokens(systemMsgs) + estimateTokens(recent) + (summary ? Math.ceil(summary.length / CHARS_PER_TOKEN) : 0);
+  if (!summary || finalLength >= estimateTokens(messages)) {
+    // No summary produced or compaction didn't help — return unchanged.
+    return messages;
+  }
+  return [
+    ...systemMsgs,
+    { role: 'user', content: '[Резюме предыдущего диалога]\n' + summary },
+    ...recent,
+  ];
+}
+
+// --- Generate a summary for the given messages via fallback chain ---
+async function getSummary(messages) {
+  const hash = crypto.createHash('sha256').update(JSON.stringify(messages)).digest('hex');
+  if (summaryCache.has(hash)) {
+    return summaryCache.get(hash);
+  }
+  const raw = await summarizeViaChain(messages);
+  const { summary, facts } = parseSummaryResponse(raw);
+  // Long-term memory: keep facts as a side effect of the same LLM call (no extra cost).
+  if (facts.length > 0) ingestFacts(facts, hash);
+  if (summary) {
+    if (summaryCache.size >= SUMMARY_CACHE_MAX) {
+      // Evict oldest inserted entry.
+      const firstKey = summaryCache.keys().next().value;
+      summaryCache.delete(firstKey);
+    }
+    summaryCache.set(hash, summary);
+  }
+  return summary;
+}
+
+// --- Call long-context models in order until one returns a summary ---
+async function summarizeViaChain(messages) {
+  const system = 'Ты — система компактизации контекста. Сожми старую часть диалога в ПОДРОБНОЕ резюме, чтобы читатель мог продолжить работу без потери контекста.\n\n' +
+    'Обязательно сохрани:\n' +
+    '1. ЦЕЛЬ задачи и над чем работали (проект, файлы, функции)\n' +
+    '2. Принятые РЕШЕНИЯ и почему\n' +
+    '3. Достигнутый ПРОГРЕСС и текущий статус (что готово, что нет)\n' +
+    '4. Ключевые факты, найденные ошибки, исправления\n' +
+    '5. Следующие шаги / что осталось сделать\n\n' +
+    'Пиши структурированно и подробно (до ' + SUMMARY_MAX_TOKENS + ' токенов). Не выдумывай. Верни только текст резюме, без вступлений.\n\n' +
+    'Идеально — сразу JSON вида {"summary": "<резюме>", "facts": ["<факт1>", "<факт2>"]}, где facts — до 5 коротких фактов (имена файлов/функций, принятые решения, найденные ошибки, текущий статус). Если JSON неудобен — просто текст резюме; он будет использован как есть.';
+  const textToSummarize = JSON.stringify(messages);
+  for (const key of SUMMARIZERS) {
+    const provider = PROVIDERS[key];
+    if (!provider || !provider.enabled) continue;
+    try {
+      const result = await callProvider(provider, {
+        model: provider.model,
+        messages: [
+          { role: 'system', content: system },
+          { role: 'user', content: 'Сожми следующий диалог:\n\n' + textToSummarize },
+        ],
+        max_tokens: SUMMARY_MAX_TOKENS,
+      }, 30000, 1);
+      const summary = result.data?.choices?.[0]?.message?.content;
+      if (summary && summary.trim().length >= 10) {
+        return summary.trim();
+      }
+    } catch (err) {
+      // try next summarizer
+    }
+  }
+  return '';
+}
+
+module.exports = { estimateTokens, prepareMessages, compactOld, getSummary, summaryCache, COMPACT_THRESHOLD, KEEP_RECENT_TOKENS, SUMMARY_MAX_TOKENS, SUMMARIZERS, parseSummaryResponse, ingestFacts, setMemory, MAX_FACTS_PER_COMPACTION, compactionThresholdFor, MAX_COMPACT_THRESHOLD };

package/lib/contextstats.js

@@ -0,0 +1,224 @@
+// lib/contextstats.js
+// Контекстная телеметрия: агрегаты «где теряется контекст» по бакетам
+// isoHour|provider. Zero-dep, никогда не бросает, переживает рестарты через
+// stats.context в state.json (см. lib/health.js).
+
+const ISO_HOUR_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:00$/;
+const RETENTION_MS = 7 * 24 * 3600 * 1000;
+
+function isoHourOf(ts) {
+  const d = new Date(ts);
+  d.setMinutes(0, 0, 0);
+  return d.toISOString().slice(0, 13) + ':00'; // "2026-08-29T20:00"
+}
+
+function tsOfHour(hour) {
+  return Date.parse(hour + ':00Z');
+}
+
+function emptyBucket(hour, provider) {
+  return {
+    key: hour + '|' + provider,
+    hour,
+    provider,
+    ts: tsOfHour(hour),
+    requests: 0,
+    sumEst: 0,
+    sumReal: 0,
+    ratioSum: 0,
+    ratioCount: 0,
+    ratioMax: 0,
+    nearWindow: 0,
+    overWindow: 0,
+    compactCount: 0,
+    upgradedCount: 0,
+    memoryCount: 0,
+    cacheExact: 0,
+    cacheSem: 0,
+    status200: 0,
+    status400: 0,
+    status429: 0,
+    statusOther: 0,
+    sysShareSum: 0,
+    tasks: { coding: 0, reasoning: 0, search: 0, chat: 0 },
+  };
+}
+
+class ContextStats {
+  constructor() {
+    this.buckets = new Map(); // key -> bucket
+  }
+
+  record(m) {
+    try {
+      if (!m || typeof m !== 'object') return;
+      const provider = (typeof m.provider === 'string' && m.provider.length > 0) ? m.provider : 'unknown';
+      const hour = isoHourOf(typeof m.ts === 'number' && m.ts > 0 ? m.ts : Date.now());
+      const key = hour + '|' + provider;
+      let b = this.buckets.get(key);
+      if (!b) { b = emptyBucket(hour, provider); this.buckets.set(key, b); }
+
+      b.requests++;
+      if (typeof m.est === 'number' && m.est > 0) b.sumEst += m.est;
+      if (typeof m.real === 'number' && m.real > 0) {
+        b.sumReal += m.real;
+        const win = (typeof m.win === 'number' && m.win > 0) ? m.win : 0;
+        if (win > 0) {
+          const ratio = m.real / win;
+          b.ratioSum += ratio;
+          b.ratioCount++;
+          if (ratio > b.ratioMax) b.ratioMax = ratio;
+          if (m.real > win) b.overWindow++;
+          else if (ratio >= 0.9) b.nearWindow++;
+        }
+      }
+      if (m.compacted) b.compactCount++;
+      if (m.upgraded) b.upgradedCount++;
+      if (m.memory) b.memoryCount++;
+      if (m.taskCategory && b.tasks && typeof b.tasks[m.taskCategory] === 'number') b.tasks[m.taskCategory]++;
+      if (m.cacheType === 'exact') b.cacheExact++;
+      else if (m.cacheType === 'semcache') b.cacheSem++;
+      if (typeof m.sysShare === 'number' && m.sysShare > 0 && m.sysShare <= 1) b.sysShareSum += m.sysShare;
+      const st = typeof m.status === 'number' ? m.status : 0;
+      if (st === 200) b.status200++;
+      else if (st === 400) b.status400++;
+      else if (st === 429) b.status429++;
+      else if (st > 0) b.statusOther++;
+    } catch (err) {
+      // Никогда не валим запрос из-за телеметрии.
+    }
+  }
+
+  prune() {
+    const cutoff = Date.now() - RETENTION_MS;
+    for (const [key, b] of this.buckets) {
+      if (b.ts < cutoff) this.buckets.delete(key);
+    }
+  }
+
+  snapshot(windowMs = RETENTION_MS) {
+    this.prune();
+    const cutoff = Date.now() - windowMs;
+    const out = [];
+    for (const b of this.buckets.values()) {
+      if (b.ts < cutoff) continue;
+      out.push(b);
+    }
+    out.sort((x, y) => (x.key < y.key ? -1 : x.key > y.key ? 1 : 0));
+    return { buckets: out };
+  }
+
+  serialize() {
+    this.prune();
+    return { buckets: [...this.buckets.values()] };
+  }
+
+  load(saved) {
+    try {
+      this.buckets = new Map();
+      if (!saved || !Array.isArray(saved.buckets)) return;
+      const now = Date.now();
+      for (const raw of saved.buckets) {
+        if (!raw || typeof raw !== 'object' || typeof raw.key !== 'string') continue;
+        const sep = raw.key.indexOf('|');
+        if (sep < 0) continue;
+        const hour = raw.key.slice(0, sep);
+        const provider = raw.key.slice(sep + 1);
+        if (!ISO_HOUR_RE.test(hour) || provider.length === 0) continue;
+        const b = emptyBucket(hour, provider);
+        for (const f of Object.keys(b)) {
+          if (f === 'key' || f === 'hour' || f === 'provider' || f === 'ts') continue;
+          if (typeof raw[f] === 'number' && raw[f] >= 0) b[f] = raw[f];
+        }
+        if (raw.tasks && typeof raw.tasks === 'object') {
+          for (const k of Object.keys(b.tasks)) {
+            if (typeof raw.tasks[k] === 'number' && raw.tasks[k] >= 0) b.tasks[k] = raw.tasks[k];
+          }
+        }
+        // ratioCount добавлен позже: у legacy-бакетов ratioSum есть, а ratioCount
+        // нет (или 0). Обнуляем ratioSum, чтобы свежие записи не смешивались с
+        // legacy-суммой (иначе avgRatio завышается). ratioMax сохраняем — он
+        // по-прежнему точен для «Max ratio».
+        if (b.ratioSum > 0 && b.ratioCount === 0) b.ratioSum = 0;
+        if (b.ts > now - RETENTION_MS) this.buckets.set(b.key, b);
+      }
+    } catch (err) {
+      this.buckets = new Map();
+    }
+  }
+
+  summary(now = Date.now()) {
+    const winMs = 24 * 3600 * 1000;
+    const cutoff = now - winMs;
+    let totalRequests = 0;
+    let ratioSum = 0;
+    let ratioCount = 0;
+    let ratioMax = 0;
+    let nearWindow = 0;
+    let overWindow = 0;
+    let compactCount = 0;
+    let upgradedCount = 0;
+    let cacheHits = 0;
+    let sysShareSum = 0;
+    let sysShareRequests = 0;
+    const providers = {};
+    let taskTotal = 0;
+    const tasks = { coding: 0, reasoning: 0, search: 0, chat: 0 };
+
+    for (const b of this.buckets.values()) {
+      if (b.ts < cutoff) continue;
+      totalRequests += b.requests;
+      if (b.ratioCount > 0) {
+        ratioSum += b.ratioSum;
+        ratioCount += b.ratioCount;
+      }
+      if (b.ratioMax > ratioMax) ratioMax = b.ratioMax;
+      nearWindow += b.nearWindow;
+      overWindow += b.overWindow;
+      compactCount += b.compactCount;
+      upgradedCount += b.upgradedCount;
+      cacheHits += b.cacheExact + b.cacheSem;
+      if (b.sysShareSum > 0) { sysShareSum += b.sysShareSum; sysShareRequests += b.requests; }
+      for (const key of Object.keys(tasks)) {
+        const n = (b.tasks && b.tasks[key]) || 0;
+        if (n > 0) { tasks[key] += n; taskTotal += n; }
+      }
+      const p = providers[b.provider] || (providers[b.provider] = { requests: 0, nearWindow: 0, overWindow: 0, compactCount: 0, upgradedCount: 0 });
+      p.requests += b.requests;
+      p.nearWindow += b.nearWindow;
+      p.overWindow += b.overWindow;
+      p.compactCount += b.compactCount;
+      p.upgradedCount += b.upgradedCount;
+    }
+
+    const narrowProviders = Object.keys(providers)
+      .filter(k => providers[k].requests >= 20 && providers[k].nearWindow / providers[k].requests >= 0.2)
+      .sort();
+
+    let status = 'OK';
+    if (overWindow > 0) status = 'OVERFLOW';
+    else if (sysShareRequests > 0 && sysShareSum / sysShareRequests >= 0.5) status = 'SYS_HEAVY';
+    else if (narrowProviders.length > 0) status = 'NARROW';
+
+    return {
+      status,
+      totalRequests,
+      ratePerHour: Math.round((totalRequests / 24) * 10) / 10,
+      avgRatio: ratioCount > 0 ? Math.round((ratioSum / ratioCount) * 1000) / 1000 : 0,
+      ratioMax: Math.round(ratioMax * 1000) / 1000,
+      nearWindow,
+      overWindow,
+      narrowProviders,
+      compactCount,
+      upgradedCount,
+      cacheHits,
+      cacheHitRate: totalRequests > 0 ? Math.round((cacheHits / totalRequests) * 100) : 0,
+      avgSysShare: sysShareRequests > 0 ? Math.round((sysShareSum / sysShareRequests) * 1000) / 1000 : 0,
+      tasks,
+      taskTotal,
+      providers,
+    };
+  }
+}
+
+module.exports = { ContextStats, isoHourOf, tsOfHour };