micro-models-agent 2.11.0 → 2.12.0

package/dist/config/registry.js

@@ -0,0 +1,584 @@
+import { DEFAULTS } from "./defaults";
+import { DEFAULT_SECURITY_CONFIG } from "./security";
+import { setBudgetShare } from "./budget";
+import { readMmaVersion } from "../core/version";
+import { EXTRA_DEFS } from "./registry-extra";
+/** Допустимые уровни reasoning. */
+export const REASONING_LEVELS = [
+    "auto",
+    "default",
+    "none",
+    "low",
+    "medium",
+    "high",
+    "max",
+];
+/** Допустимые уровни лога. */
+export const LOG_LEVELS = ["silent", "error", "warn", "info", "debug"];
+/** Допустимые уровни болтливости. */
+export const VERBOSITY_LEVELS = ["quiet", "normal", "verbose"];
+/** Допустимые локали. */
+export const LOCALES = ["en", "ru"];
+const MIN_SHARE = 0.05;
+const MAX_SHARE = 0.9;
+const MAX_COMBINED = 0.95;
+function shareField(key, canonical) {
+    const field = key === "system" ? "systemPrompt" : "responseReserve";
+    const other = key === "system" ? "responseReserve" : "systemPrompt";
+    return {
+        key: canonical,
+        aliases: [`context.${key}`],
+        domain: "budget",
+        valueType: "share",
+        min: MIN_SHARE,
+        max: MAX_SHARE,
+        step: 0.01,
+        reconfigure: true,
+        get: (c) => c.contextBudget[field],
+        set: (c, v) => setBudgetShare(c, key, v),
+        extraValidate: (c, v) => {
+            const n = v;
+            const total = n + c.contextBudget[other];
+            return total > MAX_COMBINED ? "combined" : null;
+        },
+    };
+}
+function securityToggle(field, canonical) {
+    return {
+        key: canonical,
+        aliases: [],
+        domain: "security",
+        valueType: "bool",
+        // Тулы читают `config.security` живьём; пересборка агента не нужна. Шифрование
+        // сессии снапшотится в стор на bootstrap, так что полный эффект — только со
+        // следующего запуска: reconfigure его всё равно не пересобрал бы.
+        reconfigure: false,
+        get: (c) => {
+            const sec = c.security;
+            if (!sec)
+                return false;
+            return field === "enabled" ? sec.enabled : sec[field].enabled;
+        },
+        set: (c, v) => {
+            if (!c.security)
+                c.security = structuredClone(DEFAULT_SECURITY_CONFIG);
+            if (field === "enabled")
+                c.security.enabled = v;
+            else
+                c.security[field].enabled = v;
+        },
+    };
+}
+const DEFINITIONS = [
+    {
+        key: "model",
+        aliases: [],
+        domain: "agent",
+        valueType: "string",
+        reconfigure: true,
+        get: (c) => c.model,
+        set: (c, v) => {
+            c.model = String(v);
+        },
+    },
+    {
+        key: "provider.active",
+        aliases: [],
+        domain: "provider",
+        valueType: "string",
+        reconfigure: true,
+        get: (c) => c.provider.active ?? c.provider.type,
+        set: (c, v) => {
+            c.provider.active = String(v);
+        },
+        extraValidate: (c, v) => {
+            const entries = c.provider.entries ?? [];
+            if (entries.length === 0)
+                return null;
+            const name = String(v);
+            const found = entries.some((e) => e.label === name || e.type === name);
+            return found ? null : "invalid";
+        },
+    },
+    {
+        key: "contextWindow",
+        aliases: ["context.window"],
+        domain: "budget",
+        valueType: "int",
+        min: 1024,
+        step: 1024,
+        reconfigure: true,
+        get: (c) => c.contextWindow,
+        set: (c, v) => {
+            c.contextWindow = v;
+        },
+    },
+    shareField("system", "contextBudget.systemPrompt"),
+    shareField("reserve", "contextBudget.responseReserve"),
+    {
+        key: "showReasoning",
+        aliases: ["reasoning.show"],
+        domain: "reasoning",
+        valueType: "bool",
+        reconfigure: false,
+        get: (c) => c.showReasoning,
+        set: (c, v) => {
+            c.showReasoning = v;
+        },
+    },
+    {
+        key: "reasoning.mode",
+        aliases: ["reasoning.level"],
+        domain: "reasoning",
+        valueType: "enum",
+        enumValues: REASONING_LEVELS,
+        reconfigure: true,
+        get: (c) => c.reasoning?.mode ?? "auto",
+        set: (c, v) => {
+            const base = c.reasoning ?? structuredClone(DEFAULTS.reasoning);
+            c.reasoning = { ...base, mode: v };
+        },
+    },
+    {
+        key: "ui.verbosity",
+        aliases: ["verbosity"],
+        domain: "ui",
+        valueType: "enum",
+        enumValues: VERBOSITY_LEVELS,
+        reconfigure: false,
+        get: (c) => c.ui.verbosity ?? (c.ui.verbose ? "verbose" : "quiet"),
+        set: (c, v) => {
+            c.ui.verbosity = v;
+        },
+    },
+    {
+        key: "maxToolIterations",
+        aliases: [],
+        domain: "agent",
+        valueType: "int",
+        min: 1,
+        step: 1,
+        reconfigure: false,
+        get: (c) => c.maxToolIterations,
+        set: (c, v) => {
+            c.maxToolIterations = v;
+        },
+    },
+    {
+        key: "stuckThreshold",
+        aliases: [],
+        domain: "agent",
+        valueType: "int",
+        min: 1,
+        step: 1,
+        reconfigure: false,
+        get: (c) => c.stuckThreshold,
+        set: (c, v) => {
+            c.stuckThreshold = v;
+        },
+    },
+    {
+        key: "moe.enabled",
+        aliases: [],
+        domain: "agent",
+        valueType: "bool",
+        reconfigure: true,
+        get: (c) => c.moe?.enabled ?? DEFAULTS.moe.enabled,
+        set: (c, v) => {
+            c.moe = { ...(c.moe ?? DEFAULTS.moe), enabled: v };
+        },
+    },
+    {
+        key: "moe.maxReplanCycles",
+        aliases: [],
+        domain: "agent",
+        valueType: "int",
+        min: 0,
+        max: 10,
+        step: 1,
+        reconfigure: true,
+        get: (c) => c.moe?.maxReplanCycles ?? DEFAULTS.moe.maxReplanCycles,
+        set: (c, v) => {
+            c.moe = { ...(c.moe ?? DEFAULTS.moe), maxReplanCycles: v };
+        },
+    },
+    {
+        key: "critic.enabled",
+        aliases: [],
+        domain: "agent",
+        valueType: "bool",
+        reconfigure: true,
+        get: (c) => c.critic?.enabled ?? DEFAULTS.critic.enabled,
+        set: (c, v) => {
+            c.critic = { ...(c.critic ?? DEFAULTS.critic), enabled: v };
+        },
+    },
+    {
+        key: "critic.maxCalls",
+        aliases: [],
+        domain: "agent",
+        valueType: "int",
+        min: 0,
+        max: 20,
+        step: 1,
+        reconfigure: true,
+        get: (c) => c.critic?.maxCalls ?? DEFAULTS.critic.maxCalls,
+        set: (c, v) => {
+            c.critic = { ...(c.critic ?? DEFAULTS.critic), maxCalls: v };
+        },
+    },
+    {
+        key: "critic.maxRepairCycles",
+        aliases: [],
+        domain: "agent",
+        valueType: "int",
+        min: 0,
+        max: 5,
+        step: 1,
+        reconfigure: true,
+        get: (c) => c.critic?.maxRepairCycles ?? DEFAULTS.critic.maxRepairCycles,
+        set: (c, v) => {
+            c.critic = { ...(c.critic ?? DEFAULTS.critic), maxRepairCycles: v };
+        },
+    },
+    {
+        key: "critic.timeoutMs",
+        aliases: [],
+        domain: "agent",
+        valueType: "int",
+        min: 1000,
+        max: 120000,
+        step: 1000,
+        reconfigure: true,
+        get: (c) => c.critic?.timeoutMs ?? DEFAULTS.critic.timeoutMs,
+        set: (c, v) => {
+            c.critic = { ...(c.critic ?? DEFAULTS.critic), timeoutMs: v };
+        },
+    },
+    {
+        key: "critic.model",
+        aliases: [],
+        domain: "agent",
+        valueType: "string",
+        reconfigure: true,
+        get: (c) => c.critic?.model ?? "",
+        set: (c, v) => {
+            const s = String(v).trim();
+            c.critic = { ...(c.critic ?? DEFAULTS.critic), model: s ? s : undefined };
+        },
+    },
+    {
+        key: "critic.tools",
+        aliases: [],
+        domain: "agent",
+        valueType: "bool",
+        reconfigure: true,
+        get: (c) => c.critic?.tools ?? DEFAULTS.critic.tools,
+        set: (c, v) => {
+            c.critic = { ...(c.critic ?? DEFAULTS.critic), tools: v };
+        },
+    },
+    {
+        key: "critic.provider",
+        aliases: [],
+        domain: "agent",
+        valueType: "json",
+        reconfigure: true,
+        get: (c) => c.critic?.provider ?? {},
+        set: (c, v) => {
+            const rec = v;
+            c.critic = {
+                ...(c.critic ?? DEFAULTS.critic),
+                provider: Object.keys(rec).length > 0
+                    ? rec
+                    : undefined,
+            };
+        },
+        extraValidate: (_c, v) => {
+            if (!v || typeof v !== "object" || Array.isArray(v))
+                return "invalid";
+            const rec = v;
+            if (rec.type !== undefined && typeof rec.type !== "string")
+                return "invalid";
+            if (rec.baseUrl !== undefined && typeof rec.baseUrl !== "string")
+                return "invalid";
+            if (rec.active !== undefined && typeof rec.active !== "string")
+                return "invalid";
+            if (rec.entries !== undefined && !Array.isArray(rec.entries))
+                return "invalid";
+            return null;
+        },
+    },
+    {
+        key: "logLevel",
+        aliases: [],
+        domain: "agent",
+        valueType: "enum",
+        enumValues: LOG_LEVELS,
+        reconfigure: false,
+        get: (c) => c.logLevel,
+        set: (c, v) => {
+            c.logLevel = String(v);
+        },
+    },
+    {
+        key: "locale",
+        aliases: [],
+        domain: "i18n",
+        valueType: "enum",
+        enumValues: LOCALES,
+        reconfigure: false,
+        get: (c) => c.locale,
+        set: (c, v) => {
+            c.locale = String(v);
+        },
+    },
+    {
+        key: "version",
+        aliases: [],
+        domain: "agent",
+        valueType: "string",
+        reconfigure: false,
+        readOnly: true,
+        // Версия *установленного пакета*, а не `config.version` (то — версия схемы
+        // конфига для детекта миграций, с релизом не совпадает никогда). Читается
+        // в момент вызова, так что следует за обновлениями без рестарта.
+        get: () => readMmaVersion(),
+    },
+    securityToggle("enabled", "security.enabled"),
+    securityToggle("bash", "security.bash.enabled"),
+    {
+        key: "security.bash.blockDangerousFlags",
+        aliases: [],
+        domain: "security",
+        valueType: "bool",
+        reconfigure: false,
+        get: (c) => c.security?.bash.blockDangerousFlags ?? true,
+        set: (c, v) => {
+            if (!c.security)
+                c.security = structuredClone(DEFAULT_SECURITY_CONFIG);
+            c.security.bash.blockDangerousFlags = v;
+        },
+    },
+    securityToggle("paths", "security.paths.enabled"),
+    securityToggle("contentScan", "security.contentScan.enabled"),
+    securityToggle("sessionEncryption", "security.sessionEncryption.enabled"),
+    securityToggle("network", "security.network.enabled"),
+    ...EXTRA_DEFS,
+];
+const BY_NAME = new Map();
+for (const def of DEFINITIONS) {
+    BY_NAME.set(def.key, def);
+    for (const alias of def.aliases)
+        BY_NAME.set(alias, def);
+}
+/** Резолвит ключ/алиас в деф. Нет такого — null. */
+export function resolveConfigKey(name) {
+    return BY_NAME.get(name) ?? null;
+}
+/** Все дефы реестра (идут и в комплитер без правок). */
+export function configDefs() {
+    return DEFINITIONS;
+}
+/** Все канонические ключи (для дампа), в порядке реестра. */
+export function canonicalKeys() {
+    return DEFINITIONS.map((d) => d.key);
+}
+/**
+ * Ключи канонической группы по префиксу (напр. "contextBudget" → systemPrompt,
+ * responseReserve). Матчит ровно `prefix.`, так что `/config contextBudget`
+ * листает обе доли.
+ */
+export function keysForGroup(prefix) {
+    return DEFINITIONS.filter((d) => d.key.startsWith(`${prefix}.`));
+}
+/** Канонические + алиасные имена, для автокомплита. */
+export function allConfigNames() {
+    const out = [];
+    for (const def of DEFINITIONS) {
+        out.push({ name: def.key, def, alias: false });
+        for (const a of def.aliases)
+            out.push({ name: a, def, alias: true });
+    }
+    return out;
+}
+/** Человекочитаемое форматирование значения (bool → on/off, массивы через запятую). */
+export function formatConfigValue(value) {
+    if (typeof value === "boolean")
+        return value ? "on" : "off";
+    if (Array.isArray(value))
+        return value.join(", ");
+    if (typeof value === "object" && value !== null)
+        return JSON.stringify(value);
+    return String(value);
+}
+function parseBool(raw) {
+    const v = raw.trim().toLowerCase();
+    if (["on", "true", "1", "yes", "y", "enable", "enabled"].includes(v))
+        return { ok: true, value: true };
+    if (["off", "false", "0", "no", "n", "disable", "disabled"].includes(v))
+        return { ok: true, value: false };
+    return { ok: false, reason: "invalid" };
+}
+/** Парсит сырую строку по типу ключа (bool/enum/int/share/list/json). */
+export function parseConfigValue(def, raw) {
+    const trimmed = raw.trim();
+    switch (def.valueType) {
+        case "string":
+            return trimmed.length > 0 ? { ok: true, value: trimmed } : { ok: false, reason: "invalid" };
+        case "bool":
+            return parseBool(trimmed);
+        case "enum": {
+            const v = trimmed.toLowerCase();
+            if (def.enumValues && !def.enumValues.includes(v))
+                return { ok: false, reason: "invalid" };
+            return { ok: true, value: v };
+        }
+        case "int": {
+            if (!/^-?\d+$/.test(trimmed))
+                return { ok: false, reason: "invalid" };
+            const n = Number(trimmed);
+            if (!Number.isFinite(n))
+                return { ok: false, reason: "invalid" };
+            if (def.min !== undefined && n < def.min)
+                return { ok: false, reason: "invalid" };
+            if (def.max !== undefined && n > def.max)
+                return { ok: false, reason: "invalid" };
+            return { ok: true, value: n };
+        }
+        case "share": {
+            // Доля (0.1) или проценты (10%).
+            const isPct = trimmed.endsWith("%");
+            const body = isPct ? trimmed.slice(0, -1).trim() : trimmed;
+            if (!/^-?\d+(\.\d+)?$/.test(body))
+                return { ok: false, reason: "invalid" };
+            let n = Number(body);
+            if (isPct)
+                n = n / 100;
+            if (!Number.isFinite(n) || n < MIN_SHARE || n > MAX_SHARE)
+                return { ok: false, reason: "invalid" };
+            return { ok: true, value: n };
+        }
+        case "list": {
+            if (trimmed.length === 0)
+                return { ok: true, value: [] };
+            // Структурные редакторы постят JSON-массив (значения могут содержать запятые,
+            // напр. regex вида `a{1,3}`); REPL держит синтаксис через запятую.
+            if (trimmed.startsWith("[")) {
+                try {
+                    const parsed = JSON.parse(trimmed);
+                    if (Array.isArray(parsed) && parsed.every((x) => typeof x === "string")) {
+                        return { ok: true, value: parsed };
+                    }
+                }
+                catch {
+                    /* fall through to comma splitting */
+                }
+            }
+            const items = trimmed.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+            return { ok: true, value: items };
+        }
+        case "json": {
+            if (trimmed.length > 20000)
+                return { ok: false, reason: "invalid" };
+            try {
+                return { ok: true, value: JSON.parse(trimmed) };
+            }
+            catch {
+                return { ok: false, reason: "invalid" };
+            }
+        }
+    }
+}
+/** Читает ключ конфига по имени/алиасу. */
+export function getConfigValue(config, name) {
+    const def = resolveConfigKey(name);
+    if (!def)
+        return { ok: false, reason: "unknown-key", input: name };
+    const value = def.get(config);
+    return { ok: true, key: def.key, def, value, display: formatConfigValue(value) };
+}
+/**
+ * Держит `provider.models` (последняя модель каждого провайдера) в синхроне. Запись
+ * `model` запоминается под активным провайдером; смена `provider.active`
+ * восстанавливает запомненную модель провайдера, чтобы свитч молча не оставлял
+ * модель, которую новый бэкенд не обслуживает. Заодно зеркалит легаси-плоские
+ * поля (`type`/`baseUrl`/`apiKey`) из активной записи — иначе они протухают
+ * после hot-swap, а баннер и внеполосные читатели плоских полей врут.
+ */
+/**
+ * Зеркалит легаси-плоские поля (`type`/`baseUrl`/`apiKey`) из активной записи:
+ * после hot-swap `/provider use` они протухают, а баннер и внеполосные читатели
+ * плоских полей врут.
+ */
+function mirrorActiveEntryFields(provider, activeName) {
+    const entry = (provider.entries ?? []).find((e) => e.label === activeName || e.type === activeName);
+    if (!entry)
+        return;
+    provider.type = entry.type;
+    provider.baseUrl = entry.baseUrl;
+    provider.apiKey = entry.apiKey;
+}
+function applyProviderModelMemory(config, key, value) {
+    const provider = config.provider;
+    const activeName = provider.active ?? provider.type;
+    if (key === "model") {
+        if (!activeName)
+            return;
+        provider.models = { ...(provider.models ?? {}), [activeName]: String(value) };
+        return;
+    }
+    if (key === "provider.active") {
+        const remembered = provider.models?.[String(value)];
+        if (remembered)
+            config.model = remembered;
+        mirrorActiveEntryFields(provider, String(value));
+    }
+}
+/** Пишет ключ: резолв → парсинг → валидация → set + память моделей провайдера. */
+export function setConfigValue(config, name, raw) {
+    const def = resolveConfigKey(name);
+    if (!def)
+        return { ok: false, reason: "unknown-key", input: name };
+    if (def.readOnly)
+        return { ok: false, reason: "read-only", input: name, key: def.key, def };
+    const parsed = parseConfigValue(def, raw);
+    if (!parsed.ok)
+        return { ok: false, reason: "invalid-value", input: name, key: def.key, def };
+    const extra = def.extraValidate?.(config, parsed.value);
+    if (extra)
+        return { ok: false, reason: extra, input: name, key: def.key, def };
+    def.set(config, parsed.value);
+    applyProviderModelMemory(config, def.key, parsed.value);
+    return {
+        ok: true,
+        key: def.key,
+        def,
+        value: parsed.value,
+        display: formatConfigValue(parsed.value),
+        reconfigure: def.reconfigure,
+        reasoningChanged: def.key === "reasoning.mode",
+    };
+}
+/** Проверка известности ключа (для подсказок). */
+export function isKnownConfigKey(name) {
+    return BY_NAME.has(name);
+}
+/**
+ * Снимает текущие значения всех канонических ключей. На старте REPL — "boot-снапшот",
+ * чтобы `/config reset` откатывал изменения сессии (а не прыгал к дефолтам схемы,
+ * неоднозначным для полей вида `provider.active`).
+ */
+export function captureConfigSnapshot(config) {
+    const snapshot = new Map();
+    for (const def of DEFINITIONS) {
+        try {
+            snapshot.set(def.key, structuredClone(def.get(config)));
+        }
+        catch {
+            // Частичные/мок-конфиги (тесты) могут не иметь поля — скипаем его, а не весь
+            // снапшот. Реальные конфиги полны.
+        }
+    }
+    return snapshot;
+}