| 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();
|
| }
|
|
|
| |
| |
|
|
| function normalizeScriptChar(char) {
|
| const c = String(char || "").trim().toUpperCase();
|
| const map = { "A": "А", "B": "В", "C": "С", "E": "Е", "H": "Н", "P": "Р", "X": "Х" };
|
| return map[c] || c;
|
| }
|
|
|
| |
| |
|
|
| 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 };
|
| }
|
|
|
| |
| |
|
|
| 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);
|
|
|
|
|
| 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}) определены верно` };
|
| }
|
|
|
| |
| |
|
|
| 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());
|
|
|
|
|
| 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)}...'`
|
| };
|
| }
|
| }
|
|
|
|
|
| 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)}'`
|
| };
|
| }
|
| }
|
|
|
|
|
| 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)}% пунктов списка являются дубликатами`
|
| };
|
| }
|
| }
|
|
|
|
|
| if (finishReason === "length") {
|
| return {
|
| pass: false,
|
| reason: `Генерация оборвалась по лимиту длины (успела выдать ${finalItems.length} пунктов). Декодер ушел в бесконечную петлю.`
|
| };
|
| }
|
|
|
|
|
| if (finalItems.length < 75) {
|
| return {
|
| pass: false,
|
| reason: `Сгенерировано слишком мало пунктов (${finalItems.length} из 100 требуемых).`
|
| };
|
| }
|
|
|
| return { pass: true, reason: `Успешно: сгенерировано ${finalItems.length} уникальных пунктов без зацикливаний` };
|
| }
|
|
|
| |
| |
|
|
| 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
|
| }; |
