freegate 0.6.11 → 0.6.13

package/README.md

@@ -1,10 +1,10 @@
 # Freegate
 
-[![CI](https://github.com/Artur21101965/davil-cod/actions/workflows/ci.yml/badge.svg)](https://github.com/Artur21101965/davil-cod/actions)
+[![CI](https://github.com/Artur21101965/freegate/actions/workflows/ci.yml/badge.svg)](https://github.com/Artur21101965/freegate/actions)
 [![Docker Hub](https://img.shields.io/docker/pulls/nik951751/freegate.svg)](https://hub.docker.com/r/nik951751/freegate)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![npm](https://img.shields.io/npm/v/davil-cod.svg)](https://www.npmjs.com/package/davil-cod)
-[![GitHub stars](https://img.shields.io/github/stars/Artur21101965/davil-cod?style=social)](https://github.com/Artur21101965/davil-cod)
+[![npm](https://img.shields.io/npm/v/freegate.svg)](https://www.npmjs.com/package/freegate)
+[![GitHub stars](https://img.shields.io/github/stars/Artur21101965/freegate?style=social)](https://github.com/Artur21101965/freegate)
 
 **[Русская версия](README.ru.md) · Russian version**
 
@@ -39,9 +39,9 @@ never see "rate limit", and you never pay.
 ## Quick start — 30 seconds
 
 ```bash
-npx davil-cod init -i     # wizard: password + each provider's key
-npx davil-cod start       # proxy on http://localhost:4000
-npx davil-cod test        # verify everything works
+npx freegate init -i     # wizard: password + each provider's key
+npx freegate start       # proxy on http://localhost:4000
+npx freegate test        # verify everything works
 ```
 
 Dashboard: `http://localhost:4000/?key=your_password`
@@ -49,7 +49,7 @@ Dashboard: `http://localhost:4000/?key=your_password`
 Or via Docker:
 
 ```bash
-docker run -d --name davil-cod -p 4000:4000 \
+docker run -d --name freegate -p 4000:4000 \
   -e PROVIDER_GROQ_APIKEY=... \
   -e PROVIDER_MISTRAL_APIKEY=... \
   -e AUTH=your-secret-key \
@@ -146,13 +146,13 @@ put it in `config.json` → `providers` (same format as `providers.json`).
 ## CLI commands
 
 ```bash
-npx davil-cod init              # create config
-npx davil-cod init -i           # interactive wizard (keys, password)
-npx davil-cod start             # start proxy
-npx davil-cod status            # diagnostics: providers, limits, errors
-npx davil-cod test              # verify it works
-npx davil-cod install-service   # autostart at boot
-npx davil-cod dashboard         # open dashboard
+npx freegate init              # create config
+npx freegate init -i           # interactive wizard (keys, password)
+npx freegate start             # start proxy
+npx freegate status            # diagnostics: providers, limits, errors
+npx freegate test              # verify it works
+npx freegate install-service   # autostart at boot
+npx freegate dashboard         # open dashboard
 ```
 
 ## FAQ

package/README.ru.md

@@ -1,9 +1,9 @@
 # Freegate
 
-[![CI](https://github.com/Artur21101965/davil-cod/actions/workflows/ci.yml/badge.svg)](https://github.com/Artur21101965/davil-cod/actions)
+[![CI](https://github.com/Artur21101965/freegate/actions/workflows/ci.yml/badge.svg)](https://github.com/Artur21101965/freegate/actions)
 [![Docker Hub](https://img.shields.io/docker/pulls/nik951751/freegate.svg)](https://hub.docker.com/r/nik951751/freegate)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![npm](https://img.shields.io/npm/v/davil-cod.svg)](https://www.npmjs.com/package/davil-cod)
+[![npm](https://img.shields.io/npm/v/freegate.svg)](https://www.npmjs.com/package/freegate)
 
 **English version: [README.md](README.md)**
 
@@ -38,9 +38,9 @@ DeepSeek и локальные модели. Если один провайде
 ## Быстрый старт — 30 секунд
 
 ```bash
-npx davil-cod init -i     # мастер спросит: пароль + ключи каждого провайдера
-npx davil-cod start       # прокси на http://localhost:4000
-npx davil-cod test        # проверить, что всё работает
+npx freegate init -i     # мастер спросит: пароль + ключи каждого провайдера
+npx freegate start       # прокси на http://localhost:4000
+npx freegate test        # проверить, что всё работает
 ```
 
 Дашборд: `http://localhost:4000/?key=твой_пароль`
@@ -48,7 +48,7 @@ npx davil-cod test        # проверить, что всё работает
 Или через Docker:
 
 ```bash
-docker run -d --name davil-cod -p 4000:4000 \
+docker run -d --name freegate -p 4000:4000 \
   -e PROVIDER_GROQ_APIKEY=... \
   -e PROVIDER_MISTRAL_APIKEY=... \
   -e AUTH=your-secret-key \
@@ -145,13 +145,13 @@ PROVIDER_ZAI_APIKEY=...        # ZAI
 ## Команды CLI
 
 ```bash
-npx davil-cod init              # создать конфиг
-npx davil-cod init -i           # интерактивный мастер (ключи, пароль)
-npx davil-cod start             # запустить прокси
-npx davil-cod status            # диагностика: провайдеры, лимиты, ошибки
-npx davil-cod test              # проверить, что работает
-npx davil-cod install-service   # автозапуск при старте системы
-npx davil-cod dashboard         # открыть дашборд
+npx freegate init              # создать конфиг
+npx freegate init -i           # интерактивный мастер (ключи, пароль)
+npx freegate start             # запустить прокси
+npx freegate status            # диагностика: провайдеры, лимиты, ошибки
+npx freegate test              # проверить, что работает
+npx freegate install-service   # автозапуск при старте системы
+npx freegate dashboard         # открыть дашборд
 ```
 
 ## FAQ

package/bin/freegate.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// bin/davil-cod.js — CLI wrapper + interactive setup wizard
+// bin/freegate.js — CLI wrapper + interactive setup wizard
 const path = require('path');
 const fs = require('fs');
 const { spawn } = require('child_process');
@@ -74,7 +74,7 @@ async function initWizard() {
 
   const filled = Object.values(keys).filter(Boolean).length;
   console.log(`\nГотово! Провайдеров с ключами: ${filled} из ${envVars.size}`);
-  console.log(`Запуск: npx davil-cod start  (пароль: ${authKey})`);
+  console.log(`Запуск: npx freegate start  (пароль: ${authKey})`);
 }
 
 function copyExample(name, example) {
@@ -95,8 +95,8 @@ if (cmd === 'init') {
     // Non-interactive fallback: plain copy (safe — never overwrites)
     copyExample('config.json', 'config.example.json');
     copyExample('.env', '.env.example');
-    console.log('\nГотово! Заполни .env ключами, затем: npx davil-cod start');
-    console.log('Совет: npx davil-cod init -i — интерактивный мастер с вопросами.');
+    console.log('\nГотово! Заполни .env ключами, затем: npx freegate start');
+    console.log('Совет: npx freegate init -i — интерактивный мастер с вопросами.');
   }
 } else if (cmd === 'start') {
   // Spawn from the user's cwd (not package dir) so server.js picks up their
@@ -150,10 +150,10 @@ RestartSec=5
 [Install]
 WantedBy=default.target
 `;
-    const unitPath = path.join(os.homedir(), '.config', 'systemd', 'user', 'davil-cod.service');
+    const unitPath = path.join(os.homedir(), '.config', 'systemd', 'user', 'freegate.service');
     fs.mkdirSync(path.dirname(unitPath), { recursive: true });
     fs.writeFileSync(unitPath, unit);
-    execSync(`systemctl --user daemon-reload && systemctl --user enable davil-cod && systemctl --user start davil-cod`);
+    execSync(`systemctl --user daemon-reload && systemctl --user enable freegate && systemctl --user start freegate`);
     console.log('✅ Служба автозапуска установлена (systemd)');
   }
 } else if (cmd === 'dashboard') {
@@ -174,7 +174,7 @@ WantedBy=default.target
     });
   }).on('error', (err) => {
     console.log('❌ Прокси не запущен на ' + base);
-    console.log('   Запусти: npx davil-cod start');
+    console.log('   Запусти: npx freegate start');
     process.exit(1);
   });
 } else if (cmd === 'status') {
@@ -189,7 +189,7 @@ WantedBy=default.target
     res.on('end', () => {
       if (res.statusCode !== 200) {
         console.log('❌ Прокси не отвечает (HTTP ' + res.statusCode + ')');
-        console.log('   Запусти: npx davil-cod start');
+        console.log('   Запусти: npx freegate start');
         process.exit(1);
       }
       try {
@@ -211,7 +211,7 @@ WantedBy=default.target
     });
   }).on('error', () => {
     console.log('❌ Прокси не запущен на ' + base);
-    console.log('   Запусти: npx davil-cod start');
+    console.log('   Запусти: npx freegate start');
     process.exit(1);
   });
 } else if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
@@ -220,10 +220,10 @@ WantedBy=default.target
 } else {
   console.log('Freegate — бесплатный LLM-прокси с failover');
   console.log('Команды:');
-  console.log('  npx davil-cod init       интерактивная настройка (ключи, пароль)');
-  console.log('  npx davil-cod start      запустить прокси');
-  console.log('  npx davil-cod status     диагностика: провайдеры, лимиты, ошибки');
-  console.log('  npx davil-cod test       проверить, что прокси работает');
-  console.log('  npx davil-cod dashboard  открыть дашборд');
-  console.log('  npx davil-cod install-service  автозапуск при старте системы');
+  console.log('  npx freegate init       интерактивная настройка (ключи, пароль)');
+  console.log('  npx freegate start      запустить прокси');
+  console.log('  npx freegate status     диагностика: провайдеры, лимиты, ошибки');
+  console.log('  npx freegate test       проверить, что прокси работает');
+  console.log('  npx freegate dashboard  открыть дашборд');
+  console.log('  npx freegate install-service  автозапуск при старте системы');
 }

package/lib/clean.js

@@ -65,4 +65,14 @@ function hasContent(data) {
   return content.length > 0 || reasoning.length > 0;
 }
 
-module.exports = { stripThink, cleanMessage, cleanDelta, fixReasoningMessage, hasContent };
+// Ответ короче MIN_ANSWER_LEN символов считается мусором (обрыв/один токен).
+const MIN_ANSWER_LEN = 5;
+function isTooShort(data) {
+  if (!data || !Array.isArray(data.choices)) return true;
+  const msg = data.choices[0]?.message;
+  const content = typeof msg?.content === 'string' ? msg.content.trim() : '';
+  const reasoning = typeof msg?.reasoning === 'string' ? msg.reasoning.trim() : '';
+  return (content + reasoning).length < MIN_ANSWER_LEN;
+}
+
+module.exports = { stripThink, cleanMessage, cleanDelta, fixReasoningMessage, hasContent, isTooShort, MIN_ANSWER_LEN };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freegate",
-  "version": "0.6.11",
+  "version": "0.6.13",
   "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

@@ -374,5 +374,25 @@
     "envVar": "PROVIDER_HF_APIKEY",
     "free": true,
     "category": "general"
+  },
+  "or-minimax-m3-free": {
+    "endpoint": "https://openrouter.ai/api/v1/chat/completions",
+    "model": "minimax/minimax-m3:free",
+    "priority": 20,
+    "dailyLimit": 50,
+    "keyHint": "openrouter.ai → Keys (автодобавлено, vision)",
+    "envVar": "PROVIDER_OPENROUTER_APIKEY",
+    "free": true,
+    "category": "vision"
+  },
+  "or-minimax-m2-7-free": {
+    "endpoint": "https://openrouter.ai/api/v1/chat/completions",
+    "model": "minimax/minimax-m2.7:free",
+    "priority": 20,
+    "dailyLimit": 50,
+    "keyHint": "openrouter.ai → Keys (автодобавлено, reasoning)",
+    "envVar": "PROVIDER_OPENROUTER_APIKEY",
+    "free": true,
+    "category": "reasoning"
   }
 }

package/server.js

@@ -8,7 +8,7 @@ const { loadState, initHealth, isCircuitOpen, recordSuccess, recordFailure, reco
 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 { stripThink, cleanDelta, cleanMessage, fixReasoningMessage, isTooShort, MIN_ANSWER_LEN } = require('./lib/clean');
 const { classifyComplexity, maybeUpgradeTier, classifyVisionComplexity } = require('./lib/routing');
 const logger = require('./lib/logger');
 
@@ -106,17 +106,33 @@ async function checkProvider(key, provider) {
   }
 }
 
+const PROBE_CAP = 8;
+
 async function healthCheck() {
   const now = Date.now();
-  // Параллельный пробинг: все провайдеры проверяются одновременно,
-  // а не последовательно — быстрый старт и восстановление при 30+ провайдерах.
+  // Параллельный пробинг с лимитом: пакетами по PROBE_CAP, чтобы не создавать
+  // десятки одновременных fetch-запросов при 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)));
+  for (let i = 0; i < due.length; i += PROBE_CAP) {
+    const batch = due.slice(i, i + PROBE_CAP);
+    await Promise.allSettled(batch.map(([key, provider]) => checkProvider(key, provider)));
+  }
 }
 setInterval(healthCheck, 30000);
 setTimeout(healthCheck, 1000);
 
+// Извлекает все значения content из SSE-чанка. Возвращает true, если есть
+// хотя бы одно непустое (реальный токен, а не пустая дельта).
+function chunkHasToken(str) {
+  const re = /"content"\s*:\s*"((?:[^"\\]|\\.)*)"/g;
+  let m;
+  while ((m = re.exec(str)) !== null) {
+    if (m[1].trim().length > 0) return true;
+  }
+  return false;
+}
+
 // Chat completion handler
 async function handleChatCompletion(req, res, body) {
   const requestedModel = body.model || 'tier-splus';
@@ -358,65 +374,149 @@ async function handleChatCompletion(req, res, body) {
           fixReasoningMessage(result.data.choices[0].message);
           cleanMessage(result.data.choices[0].message);
         }
-        if (!hasContent(result.data)) {
-          // Пустой ответ (провайдер-глитч) НЕ считается успехом — пробуем следующего.
-          const msg = key + ': empty response';
+        if (isTooShort(result.data)) {
+          // Пустой/мусорный ответ (провайдер-глитч) НЕ считается успехом — пробуем следующего.
+          const msg = key + ': empty or too short 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 });
+          logger.warn('Empty or too-short response, trying next provider', { key });
           continue;
         }
       }
 
-      recordSuccess(key);
-      recordRequest(key, true);
-      logger.request({ model: requestedModel, provider: key, status: 200, latency: result.latency, stream: isStreaming });
-      recordRecent({ model: requestedModel, provider: key, status: 200, latency: result.latency, cached: false });
-      recordSelection(key, provider.model, requestedModel);
-
       if (isStreaming && result.stream) {
-        res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive' });
-        const { Transform } = require('stream');
-        // Accumulate content deltas so we can cache the final answer for
-        // identical repeat prompts (opencode always streams).
         const chunks = [];
-        const cleaner = new Transform({
-          transform(chunk, encoding, callback) {
-            const str = chunk.toString();
-            // Collect SSE JSON payloads for caching (strip think blocks)
-            const lines = str.split('\n');
-            for (const line of lines) {
-              const m = line.match(/^data: (.+)$/);
-              if (!m || m[1].trim() === '[DONE]') continue;
-              try {
-                const obj = JSON.parse(m[1]);
-                const delta = obj.choices?.[0]?.delta?.content;
-                if (typeof delta === 'string') chunks.push(stripThink(delta, false));
-              } catch {}
+
+        // Очистка SSE-строки: убрать nvext, logprobs, think-блоки из дельт.
+        const cleanStr = (str) => str.replace(/^data: (.+)$/gm, (match, jsonStr) => {
+          if (jsonStr.trim() === '[DONE]') return match;
+          try {
+            const obj = JSON.parse(jsonStr);
+            delete obj.nvext;
+            if (obj.choices?.[0]) {
+              delete obj.choices[0].logprobs;
+              cleanDelta(obj.choices[0].delta);
             }
-            const cleaned = str.replace(/^data: (.+)$/gm, (match, jsonStr) => {
-              if (jsonStr.trim() === '[DONE]') return match;
-              try {
-                const obj = JSON.parse(jsonStr);
-                delete obj.nvext;
-                if (obj.choices?.[0]) {
-                  delete obj.choices[0].logprobs;
-                  cleanDelta(obj.choices[0].delta);
-                }
-                return 'data: ' + JSON.stringify(obj);
-              } catch { return match; }
-            });
-            callback(null, cleaned);
+            return 'data: ' + JSON.stringify(obj);
+          } catch { return match; }
+        });
+
+        // Сбор контент-токенов для кэша (strip think).
+        const collect = (str) => {
+          const lines = str.split('\n');
+          for (const line of lines) {
+            const m = line.match(/^data: (.+)$/);
+            if (!m || m[1].trim() === '[DONE]') continue;
+            try {
+              const obj = JSON.parse(m[1]);
+              const delta = obj.choices?.[0]?.delta?.content;
+              if (typeof delta === 'string') chunks.push(stripThink(delta, false));
+            } catch {}
           }
+        };
+
+        // Reasoning-модели (ox-alpha) думают 10с+ до первого токена — стримим сразу.
+        // Успех записываем ДО любого токена намеренно: fallback по таймауту 5с
+        // нанёс бы лишний дабл-счёт, если бы success фиксировался после первого токена.
+        if (provider.reasoning) {
+          res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive' });
+          recordSuccess(key);
+          recordRequest(key, true);
+          logger.request({ model: requestedModel, provider: key, status: 200, latency: result.latency, stream: isStreaming });
+          recordRecent({ model: requestedModel, provider: key, status: 200, latency: result.latency, cached: false });
+          recordSelection(key, provider.model, requestedModel);
+          const { Transform } = require('stream');
+          const cleaner = new Transform({
+            transform(chunk, encoding, callback) {
+              const str = chunk.toString();
+              collect(str);
+              callback(null, cleanStr(str));
+            }
+          });
+          result.stream.on('end', () => {
+            const full = chunks.join('');
+            if (full.trim().length >= MIN_ANSWER_LEN) {
+              cache.set(effectiveModel, body.messages, body.temperature, {
+                id: 'chatcmpl-cached',
+                object: 'chat.completion',
+                created: Math.floor(Date.now() / 1000),
+                model: provider.model,
+                choices: [{ index: 0, message: { role: 'assistant', content: full }, finish_reason: 'stop' }],
+                usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+              });
+            }
+            res.end();
+          });
+          result.stream.on('error', (err) => { logger.error('Stream error', { key, error: err.message }); res.end(); });
+          result.stream.pipe(cleaner).pipe(res);
+          return;
+        }
+
+        // Обычные модели: буферизуем до первого токена (макс 5 сек).
+        // Заголовки не пишем сразу — если токена нет за 5 сек, fallback.
+        const rawBuf = [];
+        const firstToken = new Promise((resolve) => {
+          let done = false;
+          const timer = setTimeout(() => { if (!done) { done = true; resolve(false); } }, 5000);
+          const finish = (ok) => { if (!done) { done = true; clearTimeout(timer); resolve(ok); } };
+          result.stream.on('data', (chunk) => {
+            const str = chunk.toString();
+            rawBuf.push(str);
+            collect(str);
+            // Первый контент-токен: хотя бы одно непустое `"content":"..."` в чанке.
+            if (chunkHasToken(str)) {
+              finish(true);
+            }
+          });
+          result.stream.once('end', () => finish(false));
+          result.stream.once('error', () => finish(false));
+        });
+
+        // Клиент отключился во время ожидания первого токена — прерываем.
+        const onClientClose = () => {
+          try { result.stream.destroy(); } catch {}
+        };
+        req.once('close', onClientClose);
+
+        const gotFirst = await firstToken;
+        if (!gotFirst) {
+          const msg = key + ': no first token within 5s';
+          errors.push(msg);
+          recordFailure(key, 0);
+          recordRequest(key, false, msg);
+          recordRecent({ model: requestedModel, provider: key, status: 204, latency: result.latency, cached: false });
+          logger.warn('Streaming fallback: no first token', { key });
+          try { result.stream.destroy(); } catch {}
+          continue; // РАБОТАЕТ — мы внутри for-цикла провайдеров.
+        }
+
+        // Первый токен пришёл: пишем заголовки, промываем буфер, дальше стримим.
+        res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive' });
+        recordSuccess(key);
+        recordRequest(key, true);
+        logger.request({ model: requestedModel, provider: key, status: 200, latency: result.latency, stream: isStreaming });
+        recordRecent({ model: requestedModel, provider: key, status: 200, latency: result.latency, cached: false });
+        recordSelection(key, provider.model, requestedModel);
+        res.on('error', (err) => {
+          logger.error('Client stream error', { key, error: err.message });
+          try { result.stream.destroy(); } catch {}
+        });
+        for (const b of rawBuf) res.write(cleanStr(b));
+        rawBuf.length = 0;
+
+        // Убираем наш 'data'-слушатель (он больше не нужен — данные уже
+        // буферизованы в rawBuf и промыты). Дальше обрабатываем вручную.
+        result.stream.removeAllListeners('data');
+        result.stream.on('data', (chunk) => {
+          const str = chunk.toString();
+          collect(str);
+          res.write(cleanStr(str));
         });
         result.stream.on('end', () => {
-          // Cache the assembled answer for repeat prompts (only if complete
-          // AND non-empty — empty answers must not be cached).
-          if (chunks.length > 0) {
-            const full = chunks.join('');
-            if (full.trim().length > 0) {
+          const full = chunks.join('');
+          if (full.trim().length >= MIN_ANSWER_LEN) {
             cache.set(effectiveModel, body.messages, body.temperature, {
               id: 'chatcmpl-cached',
               object: 'chat.completion',
@@ -425,19 +525,23 @@ async function handleChatCompletion(req, res, body) {
               choices: [{ index: 0, message: { role: 'assistant', content: full }, finish_reason: 'stop' }],
               usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
             });
-            }
           }
+          res.end();
         });
         result.stream.on('error', (err) => {
           logger.error('Stream error', { key, error: err.message });
           res.end();
         });
-        result.stream.pipe(cleaner).pipe(res);
         return;
       }
 
       if (!isStreaming && result.data) {
         // content already verified non-empty above
+        recordSuccess(key);
+        recordRequest(key, true);
+        logger.request({ model: requestedModel, provider: key, status: 200, latency: result.latency, stream: isStreaming });
+        recordRecent({ model: requestedModel, provider: key, status: 200, latency: result.latency, cached: false });
+        recordSelection(key, provider.model, requestedModel);
         cache.set(effectiveModel, body.messages, body.temperature, result.data);
         recordTokens(key, result.usage);
         res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -496,15 +600,16 @@ async function handleChatCompletion(req, res, body) {
             fixReasoningMessage(result.data.choices[0].message);
             cleanMessage(result.data.choices[0].message);
           }
-          if (!hasContent(result.data)) {
+          if (isTooShort(result.data)) {
             recordFailure(key, 0);
-            recordRequest(key, false, key + ': empty response (retry)');
-            logger.warn('Empty response in retry, trying next', { key });
+            recordRequest(key, false, key + ': empty or too short response (retry)');
+            logger.warn('Empty or too-short response in retry, trying next', { key });
             continue;
           }
           recordSuccess(key);
           recordRequest(key, true);
           recordRecent({ model: requestedModel, provider: key, status: 200, latency: result.latency, cached: false });
+          recordSelection(key, provider.model, requestedModel);
           cache.set(effectiveModel, body.messages, body.temperature, result.data);
           recordTokens(key, result.usage);
           res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -515,8 +620,56 @@ async function handleChatCompletion(req, res, body) {
           recordSuccess(key);
           recordRequest(key, true);
           recordRecent({ model: requestedModel, provider: key, status: 200, latency: result.latency, cached: false });
+          recordSelection(key, provider.model, requestedModel);
           res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive' });
-          result.stream.pipe(res);
+          const chunks = [];
+          const collectRetry = (str) => {
+            const lines = str.split('\n');
+            for (const line of lines) {
+              const m = line.match(/^data: (.+)$/);
+              if (!m || m[1].trim() === '[DONE]') continue;
+              try {
+                const obj = JSON.parse(m[1]);
+                const delta = obj.choices?.[0]?.delta?.content;
+                if (typeof delta === 'string') chunks.push(stripThink(delta, false));
+              } catch {}
+            }
+          };
+          const cleanRetry = (str) => str.replace(/^data: (.+)$/gm, (match, jsonStr) => {
+            if (jsonStr.trim() === '[DONE]') return match;
+            try {
+              const obj = JSON.parse(jsonStr);
+              delete obj.nvext;
+              if (obj.choices?.[0]) {
+                delete obj.choices[0].logprobs;
+                cleanDelta(obj.choices[0].delta);
+              }
+              return 'data: ' + JSON.stringify(obj);
+            } catch { return match; }
+          });
+          result.stream.on('data', (chunk) => {
+            const str = chunk.toString();
+            collectRetry(str);
+            res.write(cleanRetry(str));
+          });
+          result.stream.on('end', () => {
+            const full = chunks.join('');
+            if (full.trim().length >= MIN_ANSWER_LEN) {
+              cache.set(effectiveModel, body.messages, body.temperature, {
+                id: 'chatcmpl-cached',
+                object: 'chat.completion',
+                created: Math.floor(Date.now() / 1000),
+                model: provider.model,
+                choices: [{ index: 0, message: { role: 'assistant', content: full }, finish_reason: 'stop' }],
+                usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+              });
+            }
+            res.end();
+          });
+          result.stream.on('error', (err) => {
+            logger.error('Stream error (retry)', { key, error: err.message });
+            res.end();
+          });
           return;
         }
       } catch (err2) {