micro-models-agent 2.10.0 → 2.12.0

package/dist/modules/providers/manager.js

@@ -2,10 +2,10 @@ import { createProvider, defaultRegistry } from "./create";
 import { resolveCacheCapability } from "./cache";
 import { BUILTIN_PROVIDERS } from "./presets";
 /**
- * Manages the active provider + model at runtime. Supports several configured
- * providers (`ProviderConfig.entries`) with hot-swap (`switch`, `setModel`).
- * Legacy single-provider configs (`{type, baseUrl, apiKey}`) are normalized
- * into a single-entry list, so existing configs keep working.
+ * Рулит активным провайдером + моделью в рантайме. Несколько настроенных
+ * провайдеров (`ProviderConfig.entries`) с hot-swap (`switch`, `setModel`).
+ * Легаси-конфиги (`{type, baseUrl, apiKey}`) нормализуются в список из одной
+ * записи — старые конфиги продолжают работать.
  */
 export class ProviderManager {
     entries;
@@ -23,24 +23,26 @@ export class ProviderManager {
         this.lastKnownFallback = config.fallback;
         this.model = "";
     }
-    /** The model the active provider is built with. */
+    /** Модель, с которой собран активный провайдер. */
     get activeModel() {
         return this.model;
     }
-    /** Name/label of the active provider. */
+    /** Имя/label активного провайдера. */
     get activeName() {
         return this.activeProviderName;
     }
+    /** Активный провайдер (строится и кешируется). */
     get active() {
         return this.build(this.activeProviderName);
     }
+    /** Активная запись (неизвестная — ошибка). */
     get activeEntry() {
         const entry = this.entryByName(this.activeProviderName);
         if (!entry)
             throw new Error(`Unknown active provider "${this.activeProviderName}"`);
         return entry;
     }
-    /** All configured entries (resolved with preset metadata), priority-ordered. */
+    /** Все записи (с метаданными пресетов), по приоритету. */
     list() {
         return this.entries
             .map((e) => {
@@ -51,17 +53,18 @@ export class ProviderManager {
             .sort((a, b) => a.p - b.p || a.i - b.i)
             .map(({ e }) => e);
     }
+    /** Имена всех записей по приоритету. */
     listNames() {
         return this.list().map((e) => e.label);
     }
     /**
-     * CODE-ONLY capability routing (Phase 4.4): pick the first entry (priority
-     * order) whose preset capabilities and context window satisfy `needs`.
-     * Never exposed to the LLM — the model must not choose providers.
+     * CODE-ONLY роутинг capabilities: первая запись (по приоритету), чей пресет
+     * и окно контекста закрывают `needs`. Модели не exposed — модель провайдеров
+     * не выбирает.
      */
     pickFor(needs) {
         const globalWindow = this.opts.contextWindow;
-        // No constraints → keep the current active provider.
+        // Без ограничений — оставить текущий активный провайдер.
         if (!needs.vision && !needs.tools && needs.minContext === undefined) {
             return this.activeProviderName;
         }
@@ -79,7 +82,7 @@ export class ProviderManager {
         }
         return undefined;
     }
-    /** Hot-swap to a named provider; rebuild the active provider. */
+    /** Hot-swap на именованный провайдер; пересобрать активный. */
     switch(name, model) {
         if (!this.entryByName(name)) {
             throw new Error(`Unknown provider "${name}"`);
@@ -89,19 +92,23 @@ export class ProviderManager {
             this.model = model;
         return this.active;
     }
-    /** Rebuild the active provider with a new model. */
+    /** Пересобрать активный провайдер с новой моделью. */
     setModel(model) {
         this.model = model;
+        // Кэш ключуется `${name}|${model}`; старые записи под прежнюю модель
+        // бесполезны и копятся. Сбрасываем — провайдер пересоберётся под новый
+        // model при следующем обращении к `active`.
+        this.resetCache();
         return this.active;
     }
-    /** Serialize back to ProviderConfig (keeps active/entries in sync). */
+    /** Сериализовать обратно в ProviderConfig (active/entries в синхроне). */
     toConfig(fallback) {
         const active = this.activeEntry;
         return {
             active: this.activeProviderName,
             entries: this.entries,
-            // Preserve the configured value — hardcoding false silently dropped
-            // the user's provider.fallback on every hot-swap.
+            // Сохранить настроенное значение — хардкод false молча ронял
+            // пользовательский provider.fallback при каждом hot-swap.
             fallback: fallback ?? this.lastKnownFallback ?? false,
             type: active.type,
             baseUrl: active.baseUrl,
@@ -112,7 +119,7 @@ export class ProviderManager {
         if (Array.isArray(config.entries) && config.entries.length > 0) {
             return config.entries.map((e) => ({ ...e, label: e.label || e.type }));
         }
-        // Legacy single-provider form (or empty config) → one default entry.
+        // Легаси-форма одного провайдера (или пустой конфиг) → одна дефолтная запись.
         return [
             {
                 type: config.type ?? "openai-compat",
@@ -162,15 +169,39 @@ export class ProviderManager {
             return { cache: resolveCacheCapability(undefined, entry.cache) };
         return { ...spec.capabilities, cache: resolveCacheCapability(spec, entry.cache) };
     }
-    /** Clear the build cache (on config change). */
+    /** Очистить кеш сборки (при смене конфига). */
     resetCache() {
         this.cache.clear();
     }
 }
-/** Export preset metadata for the CLI (label/capabilities/baseUrl). */
+/** Метаданные пресетов для CLI (label/capabilities/baseUrl). */
 export function presetOf(type) {
     const spec = BUILTIN_PROVIDERS.find((p) => p.type === type);
     if (!spec)
         return undefined;
     return { label: spec.label, baseUrl: spec.baseUrl };
 }
+/**
+ * Эндпоинт АКТИВНОГО провайдера для внеполосных вызовов (context probe,
+ * автозагрузка моделей, ключ кеша reasoning-пробы). Легаси-плоские поля
+ * (`type`/`baseUrl`/`apiKey`) отражают активное на момент последней записи и
+ * протухают после hot-swap `/provider use` — истина в entries. Фолбэк на
+ * плоские поля для легаси-конфигов.
+ */
+export function activeProviderEndpoint(config) {
+    const entries = Array.isArray(config?.entries) ? config.entries : [];
+    const active = entries.find((e) => e.label === config?.active || e.type === config?.active) ?? entries[0];
+    if (active) {
+        return { baseUrl: active.baseUrl, apiKey: active.apiKey, type: active.type };
+    }
+    return { baseUrl: config?.baseUrl ?? "", apiKey: config?.apiKey, type: config?.type ?? "openai-compat" };
+}
+/**
+ * Стратегия reasoning АКТИВНОЙ записи провайдера (из её пресета). Легаси-плоское
+ * `type` протухает после hot-swap `/provider use` и давало чужую стратегию
+ * (напр. `prompt-tag` при активном `opencode-go`); неизвестный тип → "none".
+ */
+export function reasoningStrategyForProvider(config) {
+    const type = activeProviderEndpoint(config).type;
+    return BUILTIN_PROVIDERS.find((p) => p.type === type)?.capabilities.reasoningStrategy ?? "none";
+}

package/dist/modules/providers/naming.js

@@ -0,0 +1,15 @@
+/** Display/identity-имя записи: label, иначе type. */
+export function providerEntryName(entry) {
+    return entry.label || entry.type;
+}
+/**
+ * Занято ли `name` другой записью (кроме `exceptName`).
+ * Записи адресуются по `label || type`, легаси-поиск матчит и голый `type`,
+ * так что новый/переименованный провайдер не должен коллизить ни с тем, ни с
+ * другим — иначе `provider.active` и edit/delete молча бьют не в ту запись.
+ * `exceptName` позволяет правке сохранить собственное текущее имя.
+ */
+export function providerNameTaken(entries, name, exceptName) {
+    return entries.some((e) => providerEntryName(e) !== exceptName &&
+        (providerEntryName(e) === name || e.type === name));
+}

package/dist/modules/providers/preflight.js

@@ -0,0 +1,71 @@
+import { errMsg } from "../../utils";
+/** Base URL + ключ активного провайдера (сначала entries, потом legacy). */
+export function resolveProviderTarget(provider) {
+    const entries = provider.entries ?? [];
+    if (entries.length > 0) {
+        const active = provider.active;
+        const entry = entries.find((e) => (e.label ?? e.type) === active) ??
+            entries.find((e) => e.type === active) ??
+            entries[0];
+        return { baseUrl: entry.baseUrl, apiKey: entry.apiKey ?? "" };
+    }
+    return { baseUrl: provider.baseUrl, apiKey: provider.apiKey ?? "" };
+}
+/** Резолв активного провайдера из конфига, затем его preflight. */
+export function preflightFromConfig(ctx) {
+    const target = resolveProviderTarget(ctx.config.provider);
+    return preflightProvider({
+        baseUrl: target.baseUrl,
+        apiKey: target.apiKey,
+        model: ctx.config.model,
+    });
+}
+/** Минимальная дешёвая chat-проба: подтверждает, что модель загружена. */
+export async function probeChat(cfg, timeoutMs) {
+    const url = `${cfg.baseUrl.replace(/\/+$/, "")}/chat/completions`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const resp = await fetch(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${cfg.apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                model: cfg.model,
+                messages: [{ role: "user", content: "ok" }],
+                max_tokens: 1,
+            }),
+            signal: controller.signal,
+        });
+        if (!resp.ok)
+            throw new Error(`HTTP ${resp.status}`);
+        const data = (await resp.json());
+        const msg = data.choices?.[0]?.message;
+        return msg?.content || msg?.reasoning_content || "";
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Проверить, что провайдер отвечает и модель загружена. Один chat-вызов с
+ * max_tokens=1 (стоимость пренебрежима). Не висит: ограничен timeoutMs.
+ */
+export async function preflightProvider(cfg, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? 3000;
+    const probe = opts.probe ?? probeChat;
+    const start = Date.now();
+    try {
+        const text = await probe(cfg, timeoutMs);
+        const ms = Date.now() - start;
+        return text ? { ok: true, reason: "ok", ms } : { ok: false, reason: "no-model", ms };
+    }
+    catch (err) {
+        const ms = Date.now() - start;
+        const message = errMsg(err);
+        const reason = /abort|timeout/i.test(message) ? "timeout" : "unreachable";
+        return { ok: false, reason, ms };
+    }
+}

package/dist/modules/providers/presets.js

@@ -1,6 +1,7 @@
+// Builtin-пресеты провайдеров: capabilities, кеш-поведение, фабрики, base URL.
 // src/modules/providers/presets.ts
 import { OpenAICompatProvider } from "../../llm/openai-compat";
-/** Build an OpenAI-compatible provider (default for most backends). */
+/** Сборка OpenAI-совместимого провайдера (дефолт для большинства бэкендов). */
 function openaiCompat(opts) {
     const retry = (opts.retry ?? {
         maxRetries: 3,
@@ -48,8 +49,37 @@ const OPENAI_COMPAT = {
     },
     create: openaiCompat,
 };
-const OPENROUTER = {
-    type: "openrouter",
+/** LM Studio как first-class провайдер: тот же OpenAI-транспорт,
+ *  но свой type — native discovery (`/api/v1/models`: загруженный контекст,
+ *  capabilities) и фиксированный дефолтный URL едут с ним, а не прячутся
+ *  внутри generic-записи `openai-compat`. */
+const LMSTUDIO = {
+    type: "lmstudio",
+    label: "LM Studio (localhost:1234)",
+    baseUrl: "http://localhost:1234/v1",
+    capabilities: {
+        streaming: true,
+        tools: true,
+        vision: false,
+        reasoningStrategy: "prompt-tag",
+        listModels: true,
+        requiresKey: false,
+        auth: "bearer",
+        // Тот же локальный KV-кеш, что и у generic openai-compat.
+        cache: {
+            mechanism: "local",
+            report: "openai",
+            sessionHeader: false,
+            requestCachePrompt: false,
+            requestPromptCacheKey: false,
+            requestSessionId: false,
+            requestCacheControl: false,
+            requestStreamUsage: true,
+        },
+    },
+    create: openaiCompat,
+};
+const OPENROUTER = { type: "openrouter",
     label: "OpenRouter (openrouter.ai)",
     baseUrl: "https://openrouter.ai/api/v1",
     capabilities: {
@@ -127,9 +157,9 @@ const ANTHROPIC = {
             requestStreamUsage: false,
         },
     },
-    // The Anthropic messages API is NOT OpenAI-compatible. This preset is a
-    // placeholder until a real AnthropicProvider lands; the factory still uses
-    // the OpenAI-compatible code path today (broken), flagged via capabilities.
+    // Messages API Anthropic НЕ OpenAI-совместим. Пресет — заглушка до настоящего
+    // AnthropicProvider; фабрика пока идёт по OpenAI-кодпасу (сломано), что видно
+    // через capabilities.
     create: openaiCompat,
 };
 const OPENCODE_ZEN = {
@@ -184,16 +214,17 @@ const OPENCODE_GO = {
     },
     create: openaiCompat,
 };
-/** All builtin provider presets. */
+/** Все builtin-пресеты провайдеров. */
 export const BUILTIN_PROVIDERS = [
     OPENAI_COMPAT,
+    LMSTUDIO,
     OPENROUTER,
     OPENAI,
     ANTHROPIC,
     OPENCODE_ZEN,
     OPENCODE_GO,
 ];
-/** Fixed base URLs for hosted providers (no port scan / model autodetect). */
+/** Фиксированные base URL хостед-провайдеров (без скан-портов / автодетекта моделей). */
 export const HOSTED_BASE_URLS = {};
 for (const spec of BUILTIN_PROVIDERS) {
     if (spec.baseUrl)

package/dist/modules/providers/registry.js

@@ -1,21 +1,26 @@
 /**
- * Single source of truth mapping provider `type` → factory + capabilities.
- * Adding a provider = one `register()` call; no changes to the agent loop.
+ * Единый источник правды type → фабрика + capabilities.
+ * Добавление провайдера — один вызов `register()`; петля агента не меняется.
  */
 export class ProviderRegistry {
     specs = new Map();
+    /** Зарегистрировать спек провайдера. */
     register(spec) {
         this.specs.set(spec.type, spec);
     }
+    /** Спек по типу, иначе undefined. */
     get(type) {
         return this.specs.get(type);
     }
+    /** Зарегистрирован ли тип. */
     has(type) {
         return this.specs.has(type);
     }
+    /** Все спеки. */
     list() {
         return [...this.specs.values()];
     }
+    /** Все зарегистрированные типы. */
     types() {
         return [...this.specs.keys()];
     }

package/dist/modules/reasoning/policy.js

@@ -1,26 +1,28 @@
+/** Начальное состояние политики. */
 export function createPolicyState() {
     return { iterationsSinceRaise: 0, boostRemaining: 0 };
 }
 const DECAY_THRESHOLD = 5;
+/** Вычисляет reasoning-уровень: подъём на сбоях, буст после плана, спад на рутине. */
 export function evaluateReasoningPolicy(input, state) {
-    // Raise signals (highest priority)
+    // Сигналы подъёма (высший приоритет)
     if (input.hallucinationRetry || input.auditRejection || input.recoverableLlmError) {
         state.iterationsSinceRaise = 0;
         return { level: "high", reason: input.hallucinationRetry ? "policy:hallucination-retry" : input.auditRejection ? "policy:audit-rejection" : "policy:recoverable-llm-error" };
     }
-    // Plan created → boost for N iterations
+    // Создан план → буст на N итераций
     if (input.planCreated) {
         state.boostRemaining = 3;
         state.iterationsSinceRaise = 0;
         return { level: "high", reason: "policy:plan-created" };
     }
-    // Active boost from plan creation
+    // Активный буст от создания плана
     if (state.boostRemaining > 0) {
         state.boostRemaining--;
         state.iterationsSinceRaise = 0;
         return { level: "high", reason: "policy:plan-boost" };
     }
-    // Lower signals
+    // Сигналы понижения
     if (input.consecutiveSuccesses >= 2) {
         state.iterationsSinceRaise++;
         return { level: "low", reason: "policy:routine-write" };
@@ -29,12 +31,12 @@ export function evaluateReasoningPolicy(input, state) {
         state.iterationsSinceRaise++;
         return { level: "low", reason: "policy:repetitive-tools" };
     }
-    // Decay: if raised for too long, return to baseline
+    // Затухание: подъём держался слишком долго — возврат к базовому
     if (state.iterationsSinceRaise >= DECAY_THRESHOLD) {
         state.iterationsSinceRaise = 0;
         return { level: input.baseline, reason: "policy:decay" };
     }
-    // Default: baseline
+    // По умолчанию: базовый уровень
     state.iterationsSinceRaise++;
     return { level: input.baseline, reason: "policy:default" };
 }

package/dist/modules/reasoning/probe.js

@@ -1,30 +1,33 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { join, dirname } from "path";
-import { homedir } from "os";
+import { globalMmaDir } from "../../config/paths";
+import { readEnv } from "../../config/env";
+import { REASONING_CACHE_TTL_MS as CACHE_TTL_MS } from "../../config/timeouts";
 const PROBE_MESSAGES = [
     { role: "user", content: "Reply with exactly: ok" },
 ];
-/** TTL: re-probe after 24 hours. */
-const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
-/** Disk cache path: ~/.mma/reasoning-cache.json (override with MMA_REASONING_CACHE). */
+/** Путь дискового кэша: ~/.mma/reasoning-cache.json (переопределяется MMA_REASONING_CACHE). */
 function cachePath() {
-    return process.env.MMA_REASONING_CACHE ?? join(homedir(), ".mma", "reasoning-cache.json");
+    return readEnv("REASONING_CACHE") ?? join(globalMmaDir(), "reasoning-cache.json");
 }
-/** In-memory L1 cache (same-process fast path). */
+/** In-memory L1-кэш (быстрый путь в пределах процесса). */
 const memCache = new Map();
 /**
- * Probe whether the backend actually respects the reasoning effort mechanism.
- * Sends a trivial non-streaming request with level forced to "none" via the
- * mapped strategy. If reasoning_content still appears, the mechanism is ignored.
- */
-/**
- * Probe whether the backend actually respects the reasoning effort mechanism.
- * @returns `true` = mechanism respected, `false` = mechanism ignored,
- *          `null` = transient error (caller must NOT cache this).
+ * Проверяет, уважает ли бэкенд механизм reasoning effort.
+ * Шлёт тривиальный запрос с уровнем "none": если reasoning_content всё равно
+ * появился — механизм игнорируется.
+ * @returns `true` — механизм уважается, `false` — игнорируется,
+ *          `null` — транзиентная ошибка (вызывающий НЕ должен кэшировать).
  */
 export async function probeReasoningSupport(provider, strategy, signal) {
     if (strategy === "none")
         return false;
+    // "openai-effort" — стандартное поле OpenAI. Sentinel "none", которым проба
+    // измеряет подавление, транспорт вырезает (strict OpenAI на "none" отвечает
+    // 400), поэтому измерить нечем — считаем механизм поддерживаемым. Если
+    // бэкенд поле игнорирует, это безопасно (effort просто не влияет).
+    if (strategy === "openai-effort")
+        return true;
     try {
         let hasReasoning = false;
         for await (const chunk of provider.chat(PROBE_MESSAGES, undefined, signal, {
@@ -35,30 +38,31 @@ export async function probeReasoningSupport(provider, strategy, signal) {
             if (chunk.type === "reasoning")
                 hasReasoning = true;
         }
-        // If reasoning content appeared despite "none", the mechanism is ignored
+        // reasoning_content появился вопреки "none" — механизм игнорируется
         return !hasReasoning;
     }
     catch {
-        // Transient error (network/auth/stream) — do NOT report "not supported".
-        // Returning null signals the caller to skip caching, so a one-off failure
-        // does not disable the reasoning mechanism for the 24h TTL.
+        // Транзиентная ошибка (сеть/авторизация/стрим) — НЕ сообщаем "не поддерживается".
+        // Возврат null запрещает вызывающему кэшировать, чтобы разовый сбой
+        // не отключал reasoning-механизм на весь 24ч TTL.
         return null;
     }
 }
+/** Ключ кэша пробы: baseUrl + модель. */
 export function cacheKey(baseUrl, model) {
     return `${baseUrl}|${model}`;
 }
 /**
- * Read cached probe result. Checks in-memory first, then disk.
- * Returns `undefined` if cache miss or stale (>24h).
+ * Читает кэшированный результат пробы. Сначала память, потом диск.
+ * Возвращает `undefined` при промахе или протухании (>24ч).
  */
 export function getCachedProbeResult(key) {
-    // L1: in-memory
+    // L1: память
     const mem = memCache.get(key);
     if (mem && Date.now() - mem.ts < CACHE_TTL_MS) {
         return mem.result;
     }
-    // L2: disk
+    // L2: диск
     const disk = readDiskCache();
     const entry = disk[key];
     if (entry) {
@@ -71,7 +75,7 @@ export function getCachedProbeResult(key) {
     return undefined;
 }
 /**
- * Store probe result in both in-memory and disk cache.
+ * Кладет результат пробы в память и на диск.
  */
 export function setCachedProbeResult(key, result) {
     const now = new Date().toISOString();
@@ -80,6 +84,7 @@ export function setCachedProbeResult(key, result) {
     disk[key] = { result, ts: now };
     writeDiskCache(disk);
 }
+/** Сбрасывает кэш пробы (память + дисковый файл). */
 export function resetProbeCache() {
     memCache.clear();
     const path = cachePath();
@@ -95,7 +100,7 @@ function readDiskCache() {
         }
     }
     catch {
-        // Corrupted cache — start fresh
+        // Битый кэш — начинаем с чистого
     }
     return {};
 }
@@ -106,6 +111,6 @@ function writeDiskCache(data) {
         writeFileSync(path, JSON.stringify(data, null, 2), "utf-8");
     }
     catch {
-        // Best-effort — disk write failure must not crash the agent
+        // Best-effort: сбой записи на диск не должен ронять агента
     }
 }