micro-models-agent 0.63.0 → 1.1.0

package/dist/modules/pricing/prices.js

@@ -12,14 +12,14 @@ const ZEN_PRICES = {
     "nemotron-3-ultra-free": { input: 0, output: 0 },
     "nemotron-3.5-lightning-free": { input: 0, output: 0 },
     "muse-spark-1.2-contributor-free": { input: 0, output: 0 },
-    // MiniMax
-    "minimax-m3": { input: 0.3, output: 1.2 },
-    "minimax-m2.7": { input: 0.3, output: 1.2 },
-    "minimax-m2.5": { input: 0.3, output: 1.2 },
-    // GLM
-    "glm-5.2": { input: 1.4, output: 4.4 },
-    "glm-5.1": { input: 1.4, output: 4.4 },
-    "glm-5": { input: 1.0, output: 3.2 },
+    // MiniMax (Cached Read по прайсу Zen)
+    "minimax-m3": { input: 0.3, output: 1.2, cachedInput: 0.06 },
+    "minimax-m2.7": { input: 0.3, output: 1.2, cachedInput: 0.06 },
+    "minimax-m2.5": { input: 0.3, output: 1.2, cachedInput: 0.06 },
+    // GLM (Cached Read по прайсу Zen)
+    "glm-5.2": { input: 1.4, output: 4.4, cachedInput: 0.26 },
+    "glm-5.1": { input: 1.4, output: 4.4, cachedInput: 0.26 },
+    "glm-5": { input: 1.0, output: 3.2, cachedInput: 0.2 },
     "glm-5.3": { input: 1.4, output: 4.4 },
     // Kimi
     "kimi-k2.7-code": { input: 0.95, output: 4.0 },
@@ -108,14 +108,32 @@ export function resolvePrice(model, config) {
     return ZEN_PRICES[bare];
 }
 /**
- * Compute the cost in USD of a single call given its token usage and the
- * model price. Returns undefined when the model has no known price.
+ * Считает стоимость и экономию вызова. `promptTokens` — суммарные prompt-токены
+ * (cached + uncached); кешированная часть тарифицируется по `cachedInput`, а
+ * запись в кеш — по `cacheWrite`. Возвращает undefined без известной цены.
  */
-export function calculateCost(model, promptTokens, completionTokens, config) {
+export function calculateCostDetailed(model, promptTokens, completionTokens, config, cache) {
     const price = resolvePrice(model, config);
     if (!price)
         return undefined;
-    return (promptTokens / 1_000_000) * price.input + (completionTokens / 1_000_000) * price.output;
+    const cached = Math.max(0, cache?.cachedTokens ?? 0);
+    const write = Math.max(0, cache?.cacheWriteTokens ?? 0);
+    const uncached = Math.max(0, promptTokens - cached);
+    const cachedRate = price.cachedInput ?? price.input;
+    const writeRate = price.cacheWrite ?? 0;
+    const cost = (uncached / 1_000_000) * price.input +
+        (cached / 1_000_000) * cachedRate +
+        (write / 1_000_000) * writeRate +
+        (completionTokens / 1_000_000) * price.output;
+    const saved = (cached / 1_000_000) * (price.input - cachedRate);
+    return { cost, saved };
+}
+/**
+ * Стоимость вызова в USD (обёртка над `calculateCostDetailed`). Возвращает
+ * undefined, когда цена модели неизвестна.
+ */
+export function calculateCost(model, promptTokens, completionTokens, config, cache) {
+    return calculateCostDetailed(model, promptTokens, completionTokens, config, cache)?.cost;
 }
 /** Format a USD cost for display. Zero and very small amounts stay readable. */
 export function formatCost(cost) {

package/dist/modules/processes/index.js

@@ -1,2 +1,3 @@
 export { registerKillable, unregisterKillable, killByCallId } from "./runner";
 export { processRegistry } from "./registry";
+export { killTree } from "./kill-tree";

package/dist/modules/processes/kill-tree.js

@@ -0,0 +1,56 @@
+import { spawnSync } from "child_process";
+import { platform } from "os";
+/** Synchronous pause without blocking the event loop (via Atomics.wait). */
+function sleepSync(ms) {
+    try {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+    }
+    catch {
+        /* ignore */
+    }
+}
+function taskkillPid(pid) {
+    try {
+        spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], {
+            windowsHide: true,
+            stdio: "ignore",
+            timeout: 5000,
+        });
+    }
+    catch {
+        /* already dead */
+    }
+}
+/**
+ * Kill a spawned process tree — cross-platform.
+ *
+ * Windows: double `taskkill /T /F` with a 150ms settle gap. The second pass
+ * catches late-attaching children that were still being created during the
+ * first tree walk (e.g. `cmd.exe → node → tsserver` chains where node is
+ * still starting up when cmd is killed).
+ *
+ * POSIX: process-group kill (`-pid`). Falls back to `SIGKILL` on the direct
+ * child when the group kill fails (e.g. non-detached process).
+ */
+export function killTree(child) {
+    const pid = child.pid;
+    if (!pid)
+        return;
+    if (platform() === "win32") {
+        taskkillPid(pid);
+        sleepSync(150);
+        taskkillPid(pid);
+        return;
+    }
+    try {
+        process.kill(-pid, "SIGTERM");
+    }
+    catch {
+        try {
+            child.kill("SIGKILL");
+        }
+        catch {
+            /* already dead */
+        }
+    }
+}

package/dist/modules/processes/registry.js

@@ -1,5 +1,6 @@
 import { spawn, spawnSync } from "child_process";
 import { platform } from "os";
+import { killTree } from "./kill-tree";
 const MAX_LOG_LINES = 2000;
 const MAX_KEPT_PROCESSES = 20;
 let seq = 0;
@@ -64,60 +65,7 @@ function decodeLineToUtf8(buf) {
     }
     return buf.toString("latin1");
 }
-/** Synchronous pause without blocking the event loop (via Atomics.wait). */
-function sleepSync(ms) {
-    try {
-        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-    }
-    catch {
-        /* ignore */
-    }
-}
-function taskkillPid(pid) {
-    try {
-        spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], {
-            windowsHide: true,
-            stdio: "ignore",
-            timeout: 5000,
-        });
-    }
-    catch {
-        /* already dead */
-    }
-}
-/**
- * Kill a spawned tree on Windows.
- *
- * `taskkill /T` has a race: when cmd.exe is killed, a child (node) that is
- * still starting up can survive as an orphan because it was never attached to
- * the tree at kill time. A single pass misses it. Running taskkill twice with
- * a settle gap catches those late starters on the second pass — the second
- * tree walk sees the child that was still being created during the first one.
- * This is much cheaper than enumerating processes (wmic/PowerShell), which
- * slows every kill down to seconds under parallel load.
- */
-export function killTree(child) {
-    const pid = child.pid;
-    if (!pid)
-        return;
-    if (platform() === "win32") {
-        taskkillPid(pid);
-        sleepSync(150);
-        taskkillPid(pid);
-        return;
-    }
-    try {
-        process.kill(-pid, "SIGTERM");
-    }
-    catch {
-        try {
-            child.kill("SIGKILL");
-        }
-        catch {
-            /* already dead */
-        }
-    }
-}
+export { killTree } from "./kill-tree";
 class ProcessRegistry {
     procs = new Map();
     children = new Map();

package/dist/modules/providers/cache.js

@@ -0,0 +1,23 @@
+/**
+ * Фолбэк для провайдеров без кеша и без полей запроса о кеше. Используется,
+ * когда пресет не объявляет `cache`-возможность.
+ */
+export const NO_CACHE_CAPABILITY = {
+    mechanism: "none",
+    report: "none",
+    sessionHeader: false,
+    requestCachePrompt: false,
+    requestPromptCacheKey: false,
+    requestSessionId: false,
+    requestCacheControl: false,
+    requestStreamUsage: false,
+};
+/**
+ * Резолвит эффективную cache-возможность провайдера: дефолт пресета, поверх
+ * которого накладывается переопределение из записи конфига. Всегда возвращает
+ * новый объект, чтобы вызывающий не рисковал мутировать общее состояние.
+ */
+export function resolveCacheCapability(spec, override) {
+    const base = spec?.capabilities.cache ?? NO_CACHE_CAPABILITY;
+    return { ...base, ...(override ?? {}) };
+}

package/dist/modules/providers/factory.js

@@ -0,0 +1,28 @@
+import { ProviderManager } from "./manager";
+import { FallbackProvider } from "./fallback";
+/**
+ * Shared factory for building the ACTIVE provider from a config, used by both
+ * bootstrap and Agent.setProvider/reconfigure. Previously the three
+ * construction sites drifted — bootstrap wrapped the manager in
+ * FallbackProvider when `fallback && entries > 1`, but a hot-swap
+ * (setProvider) rebuilt a bare manager and silently dropped failover (B4).
+ * The wrapper reads `manager.active` live, so switching the manager after
+ * build keeps the failover active.
+ */
+export function buildActiveProvider(config, logger, opts) {
+    const manager = new ProviderManager(config.provider, {
+        contextWindow: config.contextWindow,
+        retry: config.retry,
+        rateLimits: config.security?.rateLimits,
+        getSessionId: opts?.getSessionId,
+        logger,
+    });
+    manager.setModel(config.model);
+    let provider = manager.active;
+    if (config.provider.fallback && manager.listNames().length > 1) {
+        provider = new FallbackProvider(manager, (from, to, error) => {
+            logger?.warn(`provider failover: ${from} -> ${to} (${error.message.slice(0, 120)})`);
+        });
+    }
+    return { manager, provider };
+}

package/dist/modules/providers/fallback.js

@@ -1,13 +1,15 @@
+import { LlmError } from "../../llm/llm-errors";
 /** True when the error is worth failing over to another provider. */
 export function isFailoverError(err) {
-    const e = err;
-    if (e?.name === "AbortError")
+    if (err instanceof Error && err.name === "AbortError")
         return false;
-    // HTTP status attached by openai-compat: retryable statuses only.
-    if (typeof e?.llmStatus === "number")
-        return e.llmStatus === 429 || e.llmStatus >= 500;
+    // HTTP status, attached by openai-compat as a typed LlmError: retryable only.
+    if (err instanceof LlmError && typeof err.llmStatus === "number") {
+        return err.llmStatus === 429 || err.llmStatus >= 500;
+    }
     // Network-level failures by errno-style code (Bun: "ConnectionRefused",
     // Node: "ECONNREFUSED", DNS: "ENOTFOUND"/"EAI_AGAIN", etc).
+    const e = err;
     const normCode = (e?.code ?? "").replace(/[-_]/g, "").toLowerCase();
     if (/^abort/.test(normCode))
         return false;

package/dist/modules/providers/health.js

@@ -1,3 +1,4 @@
+import { errMsg } from "../../utils";
 /**
  * Probe providers concurrently (bounded by the caller passing few entries)
  * and report ✓/✗ per entry. Uses `listModels()` — a free, cheap call — never
@@ -15,7 +16,7 @@ async function probeOne(target, timeoutMs) {
         return { name: target.name, ok: true, ms: Date.now() - start, models: models.length };
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
+        const message = errMsg(err);
         return {
             name: target.name,
             ok: false,

package/dist/modules/providers/index.js

@@ -1,5 +1,6 @@
 export { ProviderRegistry } from "./registry";
 export { createProvider, defaultRegistry } from "./create";
 export { ProviderManager, presetOf } from "./manager";
+export { resolveCacheCapability, NO_CACHE_CAPABILITY } from "./cache";
 export { probeProviders, targetsFromProviders, } from "./health";
 export { BUILTIN_PROVIDERS, HOSTED_BASE_URLS } from "./presets";

package/dist/modules/providers/manager.js

@@ -1,4 +1,5 @@
 import { createProvider, defaultRegistry } from "./create";
+import { resolveCacheCapability } from "./cache";
 import { BUILTIN_PROVIDERS } from "./presets";
 /**
  * Manages the active provider + model at runtime. Supports several configured
@@ -8,6 +9,7 @@ import { BUILTIN_PROVIDERS } from "./presets";
  */
 export class ProviderManager {
     entries;
+    lastKnownFallback;
     activeProviderName;
     model;
     opts;
@@ -18,6 +20,7 @@ export class ProviderManager {
         this.registry = opts.registry ?? defaultRegistry();
         this.entries = this.normalizeEntries(config);
         this.activeProviderName = this.resolveActive(config);
+        this.lastKnownFallback = config.fallback;
         this.model = "";
     }
     /** The model the active provider is built with. */
@@ -92,12 +95,14 @@ export class ProviderManager {
         return this.active;
     }
     /** Serialize back to ProviderConfig (keeps active/entries in sync). */
-    toConfig() {
+    toConfig(fallback) {
         const active = this.activeEntry;
         return {
             active: this.activeProviderName,
             entries: this.entries,
-            fallback: false,
+            // Preserve the configured value — hardcoding false silently dropped
+            // the user's provider.fallback on every hot-swap.
+            fallback: fallback ?? this.lastKnownFallback ?? false,
             type: active.type,
             baseUrl: active.baseUrl,
             apiKey: active.apiKey,
@@ -143,10 +148,20 @@ export class ProviderManager {
             retry: entry.retry ?? this.opts.retry,
             rateLimits: entry.rateLimits ?? this.opts.rateLimits,
             maxCompletionTokens: entry.maxCompletionTokens,
+            getSessionId: this.opts.getSessionId,
+            capabilities: this.resolveCapabilities(entry),
+            logger: this.opts.logger,
         }, this.registry);
         this.cache.set(key, provider);
         return provider;
     }
+    /** Возможности пресета с наложенным переопределением кеша из записи. */
+    resolveCapabilities(entry) {
+        const spec = this.registry.get(entry.type);
+        if (!spec)
+            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();

package/dist/modules/providers/presets.js

@@ -16,6 +16,9 @@ function openaiCompat(opts) {
         retry,
         rateLimits,
         maxCompletionTokens: opts.maxCompletionTokens,
+        getSessionId: opts.getSessionId,
+        cache: opts.capabilities?.cache,
+        logger: opts.logger,
     });
 }
 const OPENAI_COMPAT = {
@@ -26,10 +29,22 @@ const OPENAI_COMPAT = {
         streaming: true,
         tools: true,
         vision: false,
-        reasoningEffort: false,
+        reasoningStrategy: "prompt-tag",
         listModels: true,
         requiresKey: false,
         auth: "bearer",
+        // Локальные серверы (LM Studio, llama.cpp, vLLM) кешируют KV-префикс на
+        // сервере и отдают его в usage-полях OpenAI-формы.
+        cache: {
+            mechanism: "local",
+            report: "openai",
+            sessionHeader: false,
+            requestCachePrompt: false,
+            requestPromptCacheKey: false,
+            requestSessionId: false,
+            requestCacheControl: false,
+            requestStreamUsage: true,
+        },
     },
     create: openaiCompat,
 };
@@ -41,10 +56,22 @@ const OPENROUTER = {
         streaming: true,
         tools: true,
         vision: true,
-        reasoningEffort: false,
+        reasoningStrategy: "openai-effort",
         listModels: true,
         requiresKey: true,
         auth: "bearer",
+        // OpenRouter проксирует кеши провайдеров и сообщает cached/cache_write
+        // токены. `session_id` прибивает последующие запросы к провайдеру с тёплым кешем.
+        cache: {
+            mechanism: "auto",
+            report: "openai",
+            sessionHeader: false,
+            requestCachePrompt: false,
+            requestPromptCacheKey: false,
+            requestSessionId: true,
+            requestCacheControl: false,
+            requestStreamUsage: true,
+        },
     },
     create: openaiCompat,
 };
@@ -56,10 +83,22 @@ const OPENAI = {
         streaming: true,
         tools: true,
         vision: true,
-        reasoningEffort: true,
+        reasoningStrategy: "openai-effort",
         listModels: true,
         requiresKey: true,
         auth: "bearer",
+        // Автоматический prefix caching. `prompt_cache_key` держит запросы с общим
+        // префиксом на одном бэкенде ради более высокого hit-rate.
+        cache: {
+            mechanism: "auto",
+            report: "openai",
+            sessionHeader: false,
+            requestCachePrompt: false,
+            requestPromptCacheKey: true,
+            requestSessionId: false,
+            requestCacheControl: false,
+            requestStreamUsage: true,
+        },
     },
     create: openaiCompat,
 };
@@ -71,10 +110,22 @@ const ANTHROPIC = {
         streaming: false,
         tools: false,
         vision: true,
-        reasoningEffort: false,
+        reasoningStrategy: "none",
         listModels: false,
         requiresKey: true,
         auth: "header",
+        // Явные cache-брейкпоинты; отчёт идёт через собственные usage-поля Anthropic.
+        // Неактивно, пока не появится настоящий AnthropicProvider на /v1/messages.
+        cache: {
+            mechanism: "explicit",
+            report: "anthropic",
+            sessionHeader: false,
+            requestCachePrompt: false,
+            requestPromptCacheKey: false,
+            requestSessionId: false,
+            requestCacheControl: true,
+            requestStreamUsage: false,
+        },
     },
     // The Anthropic messages API is NOT OpenAI-compatible. This preset is a
     // placeholder until a real AnthropicProvider lands; the factory still uses
@@ -89,10 +140,22 @@ const OPENCODE_ZEN = {
         streaming: true,
         tools: true,
         vision: false,
-        reasoningEffort: false,
+        reasoningStrategy: "openai-effort",
         listModels: true,
         requiresKey: false,
         auth: "bearer",
+        // Серверный кеш с ценой Cached Read; для sticky-маршрутизации нужен
+        // заголовок сессии (`x-opencode-session`).
+        cache: {
+            mechanism: "auto",
+            report: "openai",
+            sessionHeader: true,
+            requestCachePrompt: false,
+            requestPromptCacheKey: false,
+            requestSessionId: false,
+            requestCacheControl: false,
+            requestStreamUsage: true,
+        },
     },
     create: openaiCompat,
 };
@@ -104,10 +167,20 @@ const OPENCODE_GO = {
         streaming: true,
         tools: true,
         vision: false,
-        reasoningEffort: false,
+        reasoningStrategy: "openai-effort",
         listModels: true,
         requiresKey: false,
         auth: "bearer",
+        cache: {
+            mechanism: "auto",
+            report: "openai",
+            sessionHeader: true,
+            requestCachePrompt: false,
+            requestPromptCacheKey: false,
+            requestSessionId: false,
+            requestCacheControl: false,
+            requestStreamUsage: true,
+        },
     },
     create: openaiCompat,
 };

package/dist/modules/reasoning/policy.js

@@ -0,0 +1,40 @@
+export function createPolicyState() {
+    return { iterationsSinceRaise: 0, boostRemaining: 0 };
+}
+const DECAY_THRESHOLD = 5;
+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
+    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" };
+    }
+    if (input.isRepetitive) {
+        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

@@ -0,0 +1,111 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+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). */
+function cachePath() {
+    return process.env.MMA_REASONING_CACHE ?? join(homedir(), ".mma", "reasoning-cache.json");
+}
+/** In-memory L1 cache (same-process fast path). */
+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).
+ */
+export async function probeReasoningSupport(provider, strategy, signal) {
+    if (strategy === "none")
+        return false;
+    try {
+        let hasReasoning = false;
+        for await (const chunk of provider.chat(PROBE_MESSAGES, undefined, signal, {
+            maxTokens: 32,
+            reasoningEffort: "none",
+            reasoningStrategy: strategy,
+        })) {
+            if (chunk.type === "reasoning")
+                hasReasoning = true;
+        }
+        // If reasoning content appeared despite "none", the mechanism is ignored
+        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.
+        return null;
+    }
+}
+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).
+ */
+export function getCachedProbeResult(key) {
+    // L1: in-memory
+    const mem = memCache.get(key);
+    if (mem && Date.now() - mem.ts < CACHE_TTL_MS) {
+        return mem.result;
+    }
+    // L2: disk
+    const disk = readDiskCache();
+    const entry = disk[key];
+    if (entry) {
+        const age = Date.now() - new Date(entry.ts).getTime();
+        if (age < CACHE_TTL_MS) {
+            memCache.set(key, { result: entry.result, ts: Date.now() });
+            return entry.result;
+        }
+    }
+    return undefined;
+}
+/**
+ * Store probe result in both in-memory and disk cache.
+ */
+export function setCachedProbeResult(key, result) {
+    const now = new Date().toISOString();
+    memCache.set(key, { result, ts: Date.now() });
+    const disk = readDiskCache();
+    disk[key] = { result, ts: now };
+    writeDiskCache(disk);
+}
+export function resetProbeCache() {
+    memCache.clear();
+    const path = cachePath();
+    if (existsSync(path)) {
+        writeFileSync(path, "{}", "utf-8");
+    }
+}
+function readDiskCache() {
+    try {
+        const path = cachePath();
+        if (existsSync(path)) {
+            return JSON.parse(readFileSync(path, "utf-8"));
+        }
+    }
+    catch {
+        // Corrupted cache — start fresh
+    }
+    return {};
+}
+function writeDiskCache(data) {
+    try {
+        const path = cachePath();
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, JSON.stringify(data, null, 2), "utf-8");
+    }
+    catch {
+        // Best-effort — disk write failure must not crash the agent
+    }
+}