| 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 || "General",
|
| description: `[${(s.language || "ru").toUpperCase()}] ${s.name}`
|
| }));
|
| }
|
|
|
| export function getScenarios() {
|
| return listScenarios();
|
| }
|
|
|
| |
| |
| |
| |
|
|
| function validateResponse(scenario, rawText) {
|
| const text = (rawText || "").trim();
|
| const expected = (scenario.correctAnswer || "").trim().toUpperCase();
|
|
|
|
|
| const pattern = /(?:Мой\s*ответ|My\s*answer):\s*\(([A-J])\)/gi;
|
| const matches = [...text.matchAll(pattern)];
|
|
|
| if (matches.length === 0) {
|
| return {
|
| pass: false,
|
| score: 0,
|
| extracted: null,
|
| reason: `Нарушен формат: не найдена обязательная конструкция 'Мой ответ: (БУКВА)'. Окончание ответа: "${text.slice(-100)}"`
|
| };
|
| }
|
|
|
|
|
| const lastMatch = matches[matches.length - 1];
|
| const extracted = lastMatch[1].toUpperCase();
|
|
|
| if (extracted !== expected) {
|
| return {
|
| pass: false,
|
| score: 0,
|
| extracted,
|
| reason: `Неверный ответ: модель выбрала '(${extracted})', ожидалось '(${expected})'`
|
| };
|
| }
|
|
|
| return {
|
| pass: true,
|
| score: 100,
|
| extracted,
|
| reason: `Успех: корректно выбран вариант '(${extracted})' в строгом формате 'Мой ответ: (X)'`
|
| };
|
| }
|
|
|
| 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 result = validateResponse(scenario, text);
|
|
|
| const rawLog = [
|
| `model=${input.model.model}`,
|
| `category=${scenario.category}`,
|
| `language=${scenario.language}`,
|
| `scenario=${scenario.id} - ${scenario.name}`,
|
| `prompt=${scenario.prompt}`,
|
| `assistant_full_cot_response=${text}`,
|
| `extracted_letter=${result.extracted || "NONE"}`,
|
| `expected_letter=${scenario.correctAnswer}`,
|
| `verdict=${result.pass ? "pass" : "fail"}`,
|
| `score=${result.score}`,
|
| `summary=${result.reason}`,
|
| `\n--- RAW API RESPONSE ---`,
|
| JSON.stringify(data, null, 2)
|
| ].join("\n");
|
|
|
| return {
|
| scenarioId: scenario.id,
|
| category: scenario.category,
|
| language: scenario.language,
|
| status: result.pass ? "pass" : "fail",
|
| score: result.score,
|
| 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 catMap = new Map();
|
| for (const r of scored) {
|
| const cat = r.category || "General";
|
| if (!catMap.has(cat)) {
|
| catMap.set(cat, { total: 0, count: 0 });
|
| }
|
| const entry = catMap.get(cat);
|
| entry.total += r.score || 0;
|
| entry.count += 1;
|
| }
|
|
|
| const categories = Array.from(catMap.entries()).map(([name, data]) => ({
|
| name,
|
| score: data.count > 0 ? Math.round((data.total / (data.count * 100)) * 100) : 0,
|
| count: data.count
|
| }));
|
|
|
| return {
|
| totalScore: max > 0 ? Math.round((total / max) * 100) : 0,
|
| categories
|
| };
|
| }
|
|
|
| export default {
|
| manifest,
|
| listScenarios,
|
| getScenarios,
|
| prepare,
|
| createRuntime: prepare,
|
| scoreModelResults
|
| }; |
