Upload 3 files

At the moment, the main problem is the API, which interrupts the thinking and triggers a response, since in this case it is not possible to accurately understand that the model could not exit the loop.

---
---

На данный момент, основная проблема, это API, который прерывает мышление, и запускает ответ, так как в таком случае не удаётся, точно понять, что модель, не смогла бы выйти из цикла.

RLB/benchlocal.pack.json

@@ -0,0 +1,18 @@
+{
+  "schemaVersion": 1,
+  "protocolVersion": 1,
+  "id": "repetition-loops-suite-90",
+  "name": "Изоморфный бенчмарк зацикливания x90 (Repetition Loops)",
+  "version": "6.2.0",
+  "description": "Симметричный многоуровневый бенчмарк дегенерации декодера: ровно 90 изоморфных задач (30 RU, 30 EN, 30 MIX) со строгой бинарной оценкой и защитой от списывания примеров.",
+  "entry": "./index.mjs",
+  "samplingDefaults": {
+    "temperature": 0.0
+  },
+  "capabilities": {
+    "tools": false,
+    "multiTurn": false,
+    "streamingProgress": false,
+    "verification": false
+  }
+}

RLB/index.mjs

@@ -0,0 +1,433 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const manifestPath = path.join(__dirname, "benchlocal.pack.json");
+const scenariosPath = path.join(__dirname, "scenarios.json");
+
+export const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+
+function loadScenarios() {
+  return JSON.parse(fs.readFileSync(scenariosPath, "utf8"));
+}
+
+export function listScenarios() {
+  return loadScenarios().map(s => ({
+    id: s.id,
+    name: s.name,
+    category: s.category || "Общие",
+    description: s.name
+  }));
+}
+
+export function getScenarios() {
+  return listScenarios();
+}
+
+/**
+ * Нормализация букв-омоглифов (защита от различий раскладки А/A, В/B, С/C, Е/E, Н/H, Р/P, Х/X)
+ */
+function normalizeScriptChar(char) {
+  const c = String(char || "").trim().toUpperCase();
+  const map = { "A": "А", "B": "В", "C": "С", "E": "Е", "H": "Н", "P": "Р", "X": "Х" };
+  return map[c] || c;
+}
+
+/**
+ * Детектор макро-зацикливаний (период блока от 25 до 250 слов)
+ */
+function detectMacroLoop(text) {
+  const words = (text.toLowerCase().match(/[\p{L}\p{N}'-]+/gu) || []);
+  const n = words.length;
+  if (n < 50) return { isLoop: false };
+
+  const maxL = Math.min(250, Math.floor(n / 2));
+  for (let L = 25; L <= maxL; L += 5) {
+    const step = Math.max(1, Math.floor(L / 4));
+    for (let i = 0; i <= n - 2 * L; i += step) {
+      let matches = 0;
+      for (let j = 0; j < L; j++) {
+        if (words[i + j] === words[i + L + j]) {
+          matches++;
+        }
+      }
+      const similarity = matches / L;
+      if (similarity >= 0.85) {
+        const sample = words.slice(i, i + Math.min(12, L)).join(" ");
+        return {
+          isLoop: true,
+          reason: `Макро-петля: повторяющийся блок ~${L} слов (${Math.round(similarity * 100)}% совпадения): '${sample}...'`
+        };
+      }
+    }
+  }
+
+  const paragraphs = text
+    .split(/\n+/)
+    .map(p => p.trim().toLowerCase())
+    .filter(p => p.split(/\s+/).length >= 15);
+
+  for (let i = 0; i < paragraphs.length - 1; i++) {
+    if (paragraphs[i] === paragraphs[i + 1]) {
+      return {
+        isLoop: true,
+        reason: `Повтор целого абзаца подряд: '${paragraphs[i].slice(0, 50)}...'`
+      };
+    }
+  }
+
+  return { isLoop: false };
+}
+
+/**
+ * Детектор микро-зацикливаний (слова, биграммы, короткие фразы)
+ */
+function detectMicroLoop(text, finishReason) {
+  const words = (text.toLowerCase().match(/[\p{L}\p{N}'-]+/gu) || []);
+  if (words.length < 5) return { isLoop: false };
+
+  for (let i = 0; i <= words.length - 5; i++) {
+    const w = words[i];
+    if (words[i + 1] === w && words[i + 2] === w && words[i + 3] === w && words[i + 4] === w) {
+      return { isLoop: true, reason: `Повтор слова 5+ раз подряд: '${w}'` };
+    }
+  }
+
+  for (let i = 0; i <= words.length - 8; i++) {
+    if (
+      words[i] === words[i + 2] && words[i + 1] === words[i + 3] &&
+      words[i] === words[i + 4] && words[i + 1] === words[i + 5] &&
+      words[i] === words[i + 6] && words[i + 1] === words[i + 7]
+    ) {
+      return { isLoop: true, reason: `Тандемный повтор пары слов: '${words[i]} ${words[i + 1]}'` };
+    }
+  }
+
+  const maxK = Math.min(20, Math.floor(words.length / 3));
+  for (let k = 3; k <= maxK; k++) {
+    for (let i = 0; i <= words.length - 3 * k; i++) {
+      let isMatch = true;
+      for (let j = 0; j < k; j++) {
+        if (words[i + j] !== words[i + k + j] || words[i + j] !== words[i + 2 * k + j]) {
+          isMatch = false;
+          break;
+        }
+      }
+      if (isMatch) {
+        const sample = words.slice(i, i + Math.min(k, 6)).join(" ");
+        return { isLoop: true, reason: `Тандемный повтор фразы из ${k} слов: '${sample}...'` };
+      }
+    }
+  }
+
+  if (finishReason === "length" && words.length >= 20) {
+    const tail = words.slice(-20);
+    const tailBigrams = new Set();
+    for (let i = 0; i < tail.length - 1; i++) {
+      tailBigrams.add(`${tail[i]}_${tail[i + 1]}`);
+    }
+    if (tailBigrams.size <= 4) {
+      return { isLoop: true, reason: "Аварийное зацикливание хвоста при исчерпании лимита токенов" };
+    }
+  }
+
+  return { isLoop: false };
+}
+
+/**
+ * Валидатор Категории 1: Распознавание смыслового зацикливания (Строгая бинарная оценка)
+ */
+function validateCategory1(scenario, rawText) {
+  const text = (rawText || "").trim();
+  if (!text) {
+    return { pass: false, reason: "Пустой ответ от модели" };
+  }
+
+  const pattern = /(?:мой\s+ответ|my\s+answer)\s*:\s*\(\s*([12])\s*\)\s*\(\s*([А-ЯA-Zа-яa-z])\s*\)/i;
+  const match = text.match(pattern);
+
+  if (!match) {
+    return {
+      pass: false,
+      reason: `Не соблюден формат ответа. Ожидалось: 'Мой ответ: (1/2) (Буква)', получено: '${text.slice(0, 60)}...'`
+    };
+  }
+
+  const actualBinary = match[1];
+  const actualLetterNorm = normalizeScriptChar(match[2]);
+
+  const expectedBinary = String(scenario.expectedBinary);
+  const expectedLetterNorm = normalizeScriptChar(scenario.expectedLetter);
+
+  // СТРОГАЯ БИНАРНАЯ ПРОВЕРКА: Либо верны оба пункта (100), либо провал (0)
+  if (actualBinary !== expectedBinary || actualLetterNorm !== expectedLetterNorm) {
+    const verdictName = actualBinary === "1" ? "Да" : "Нет";
+    const expVerdictName = expectedBinary === "1" ? "Да" : "Нет";
+    return {
+      pass: false,
+      reason: `Задание не выполнено. Получено: (${actualBinary} - ${verdictName}) (${match[2].toUpperCase()}), ожидалось: (${expectedBinary} - ${expVerdictName}) (${scenario.expectedLetter})`
+    };
+  }
+
+  return { pass: true, reason: `Задание выполнено полностью: зацикливание и количество (${expectedBinary}) (${scenario.expectedLetter}) определены верно` };
+}
+
+/**
+ * Валидатор Категории 2: Массовая генерация 100 элементов
+ */
+function validateCategory2(scenario, rawText, finishReason) {
+  const text = (rawText || "").trim();
+  if (!text) {
+    return { pass: false, reason: "Пустой ответ от модели" };
+  }
+
+  const lines = text.split(/\n+/).map(l => l.trim()).filter(Boolean);
+  const items = [];
+
+  for (const line of lines) {
+    const m = line.match(/^(?:\d+[\.\)]|\-\s*|\*\s*)(.+)$/);
+    if (m) {
+      items.push(m[1].trim().toLowerCase());
+    }
+  }
+
+  const finalItems = items.length >= 40 ? items : lines.map(l => l.toLowerCase());
+
+  // 1. Повтор одного пункта 4+ раза подряд
+  for (let i = 0; i <= finalItems.length - 4; i++) {
+    if (
+      finalItems[i] === finalItems[i + 1] &&
+      finalItems[i] === finalItems[i + 2] &&
+      finalItems[i] === finalItems[i + 3]
+    ) {
+      return {
+        pass: false,
+        reason: `[LOOP DETECTED] Непрерывный повтор одного пункта 4+ раза подряд: '${finalItems[i].slice(0, 40)}...'`
+      };
+    }
+  }
+
+  // 2. Чередование пары пунктов ((A B) (A B) (A B))
+  for (let i = 0; i <= finalItems.length - 6; i++) {
+    if (
+      finalItems[i] === finalItems[i + 2] && finalItems[i] === finalItems[i + 4] &&
+      finalItems[i + 1] === finalItems[i + 3] && finalItems[i + 1] === finalItems[i + 5]
+    ) {
+      return {
+        pass: false,
+        reason: `[LOOP DETECTED] Циклическое чередование пунктов: '${finalItems[i].slice(0, 25)}' / '${finalItems[i + 1].slice(0, 25)}'`
+      };
+    }
+  }
+
+  // 3. Коллапс разнообразия (> 35% дубликатов по всему списку)
+  if (finalItems.length >= 40) {
+    const unique = new Set(finalItems);
+    const dupRatio = (finalItems.length - unique.size) / finalItems.length;
+    if (dupRatio > 0.35) {
+      return {
+        pass: false,
+        reason: `[LOOP DETECTED] Коллапс генератора: ${Math.round(dupRatio * 100)}% пунктов списка являются дубликатами`
+      };
+    }
+  }
+
+  // 4. Обрыв по лимиту длины
+  if (finishReason === "length") {
+    return {
+      pass: false,
+      reason: `Генерация оборвалась по лимиту длины (успела выдать ${finalItems.length} пунктов). Декодер ушел в бесконечную петлю.`
+    };
+  }
+
+  // 5. Полнота объема (допуск от 75 пунктов)
+  if (finalItems.length < 75) {
+    return {
+      pass: false,
+      reason: `Сгенерировано слишком мало пунктов (${finalItems.length} из 100 требуемых).`
+    };
+  }
+
+  return { pass: true, reason: `Успешно: сгенерировано ${finalItems.length} уникальных пунктов без зацикливаний` };
+}
+
+/**
+ * Валидатор Категории 3: Рекурсивные правила и парадоксы
+ */
+function validateCategory3(scenario, rawText, finishReason) {
+  const text = (rawText || "").trim();
+  const words = text.split(/\s+/).filter(Boolean);
+
+  if (words.length === 0) {
+    return { pass: false, reason: "Отказ генерации: модель не вернул�� текста (зависание или сбой декодера)" };
+  }
+
+  if (words.length < 10) {
+    return {
+      pass: false,
+      reason: `Нарушено условие минимального объема: ответ содержит всего ${words.length} слов (требуется >= 10 слов)`
+    };
+  }
+
+  const micro = detectMicroLoop(text, finishReason);
+  if (micro.isLoop) {
+    return { pass: false, reason: `[LOOP DETECTED] ${micro.reason}` };
+  }
+
+  const macro = detectMacroLoop(text);
+  if (macro.isLoop) {
+    return { pass: false, reason: `[LOOP DETECTED] ${macro.reason}` };
+  }
+
+  if (finishReason === "length") {
+    return { pass: false, reason: "Модель исчерпала лимит токенов в попытке распутать рекурсивный дедлок" };
+  }
+
+  return { pass: true, reason: "Успешно: модель справилась с задачей без впадения в петлю генерации" };
+}
+
+function validateResponse(scenario, rawText, finishReason) {
+  if (scenario.category === "Определение зацикливания") {
+    return validateCategory1(scenario, rawText);
+  }
+  if (scenario.category === "Массовая генерация (100 элементов)") {
+    return validateCategory2(scenario, rawText, finishReason);
+  }
+  if (scenario.category === "Рекурсивные правила и парадоксы") {
+    return validateCategory3(scenario, rawText, finishReason);
+  }
+  return { pass: false, reason: "Неизвестная категория сценария" };
+}
+
+function resolveHelpers(context) {
+  if (context && typeof context.getRequiredProvider === "function") {
+    return context;
+  }
+  if (context?.helpers && typeof context.helpers.getRequiredProvider === "function") {
+    return context.helpers;
+  }
+  return {
+    getRequiredProvider(providerId) {
+      const providers = context?.providers || [];
+      const found = Array.isArray(providers)
+        ? providers.find((p) => p.id === providerId || p.provider === providerId)
+        : providers[providerId];
+      return found || { baseUrl: "http://127.0.0.1:11434/v1", apiKey: "none" };
+    },
+    getInferenceEndpoint(modelId) {
+      return context?.endpoints?.[modelId] || null;
+    }
+  };
+}
+
+export async function prepare(context) {
+  const helpers = resolveHelpers(context);
+
+  return {
+    async runScenario(input) {
+      const allScenarios = loadScenarios();
+      const scenario = allScenarios.find(s => s.id === input.scenario.id);
+      if (!scenario) {
+        return {
+          scenarioId: input.scenario.id,
+          status: "fail",
+          score: 0,
+          summary: "Сценарий не найден",
+          rawLog: "error=Scenario not found"
+        };
+      }
+
+      const provider = helpers.getRequiredProvider(input.model.provider, { enabledOnly: true });
+      const inference = helpers.getInferenceEndpoint ? helpers.getInferenceEndpoint(input.model.id) : null;
+
+      const rawBaseUrl = (inference && inference.status === "running" ? inference.baseUrl : provider?.baseUrl) || "http://127.0.0.1:11434/v1";
+      const baseUrl = rawBaseUrl.replace(/\/+$/, "");
+      const apiKey = provider?.apiKey || "none";
+
+      const requestBody = {
+        model: input.model.model,
+        messages: [{ role: "user", content: scenario.prompt }],
+        temperature: 0
+      };
+
+      const response = await fetch(`${baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify(requestBody)
+      });
+
+      const data = await response.json();
+      const text = (data.choices?.[0]?.message?.content || "").trim();
+      const finishReason = data.choices?.[0]?.finish_reason || "stop";
+      const result = validateResponse(scenario, text, finishReason);
+
+      const rawLog = [
+        `model=${input.model.model}`,
+        `scenario=${scenario.id} ${scenario.name}`,
+        `category=${scenario.category}`,
+        `finish_reason=${finishReason}`,
+        `user_turn_1=${scenario.prompt}`,
+        `assistant_turn_1=${text}`,
+        `final_answer=${text}`,
+        `verdict=${result.pass ? "pass" : "fail"}`,
+        `score=${result.pass ? 100 : 0}`,
+        `summary=${result.reason}`,
+        `\n--- RAW API RESPONSE ---`,
+        JSON.stringify(data, null, 2)
+      ].join("\n");
+
+      return {
+        scenarioId: scenario.id,
+        status: result.pass ? "pass" : "fail",
+        score: result.pass ? 100 : 0,
+        summary: result.reason,
+        rawLog: rawLog
+      };
+    },
+
+    async dispose() {}
+  };
+}
+
+export function scoreModelResults(results) {
+  const scored = results || [];
+  const total = scored.reduce((sum, r) => sum + (r.score || 0), 0);
+  const max = scored.length * 100;
+
+  const scenarios = loadScenarios();
+  const categoryMap = new Map();
+
+  for (const r of scored) {
+    const sc = scenarios.find(s => s.id === r.scenarioId);
+    const cat = sc?.category || "Общие";
+    if (!categoryMap.has(cat)) {
+      categoryMap.set(cat, { total: 0, count: 0 });
+    }
+    const cur = categoryMap.get(cat);
+    cur.total += r.score || 0;
+    cur.count += 1;
+  }
+
+  const categories = Array.from(categoryMap.entries()).map(([name, data]) => ({
+    name,
+    score: data.count > 0 ? Math.round(data.total / data.count) : 0
+  }));
+
+  return {
+    totalScore: max > 0 ? Math.round((total / max) * 100) : 0,
+    categories
+  };
+}
+
+export default {
+  manifest,
+  listScenarios,
+  getScenarios,
+  prepare,
+  createRuntime: prepare,
+  scoreModelResults
+};