micro-models-agent 2.11.0 → 2.12.0

package/dist/llm/image-utils.js

@@ -1,3 +1,4 @@
+/** Картинки: MIME, буфер обмена, загрузка файла/URL в data URL. */
 import { readFileSync } from "fs";
 import { extname } from "path";
 const MIME_MAP = {
@@ -9,31 +10,54 @@ const MIME_MAP = {
     ".bmp": "image/bmp",
     ".svg": "image/svg+xml",
 };
-/** Detect MIME type from file extension. */
+/**
+ * Определяет MIME-тип по расширению файла.
+ * @param filePath путь к файлу; @returns MIME-тип (дефолт image/png).
+ */
 export function detectMime(filePath) {
     const ext = extname(filePath).toLowerCase();
     return MIME_MAP[ext] ?? "image/png";
 }
+/** Конструктор Bun.Image под Bun, иначе undefined. */
+function getBunImage() {
+    return globalThis.Bun?.Image;
+}
+/** Ужимает буфер в JPEG data URL через Bun.Image; null, если недоступно/упало. */
+async function resizeToJpegDataUrl(buf) {
+    const Image = getBunImage();
+    if (!Image)
+        return null;
+    try {
+        const img = new Image(buf);
+        const { width } = await img.metadata();
+        const targetWidth = Math.min(800, width || 800);
+        return await img.resize(targetWidth, 800, { fit: "inside" }).jpeg({ quality: 60 }).dataurl();
+    }
+    catch {
+        return null;
+    }
+}
 /**
- * Read image from system clipboard using Bun.Image (macOS/Windows).
- * Falls back to platform-specific commands on Linux.
- * Returns null if clipboard has no image.
+ * Читает картинку из буфера обмена через Bun.Image (macOS/Windows).
+ * На Linux — платформенные команды. Null, если картинки нет.
+ * @returns буфер PNG/JPEG либо null.
  */
 export async function readClipboardImage() {
-    // Bun.Image.fromClipboard() works on macOS and Windows
-    if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
+    // Bun.Image.fromClipboard() работает на macOS и Windows
+    const Image = getBunImage();
+    if (Image) {
         try {
-            const img = Bun.Image.fromClipboard();
+            const img = Image.fromClipboard();
             if (img) {
                 const buf = await img.resize(800, 800, { fit: "inside" }).jpeg({ quality: 60 }).buffer();
                 return Buffer.from(buf);
             }
         }
         catch {
-            // Bun.Image.fromClipboard() failed — fall through to platform fallback
+            // Bun.Image.fromClipboard() упал — идём в платформенный фолбэк
         }
     }
-    // Linux fallback: xclip/wl-paste → temp file → read
+    // Linux-фолбэк: xclip/wl-paste → временный файл → чтение
     return readClipboardFallback();
 }
 async function readClipboardFallback() {
@@ -44,7 +68,7 @@ async function readClipboardFallback() {
     if (platform() !== "linux")
         return null; // macOS/Windows use Bun.Image
     const tmpPath = join(process.env.TEMP || process.env.TMP || "/tmp", `mma-clip-${Date.now()}.png`);
-    // Try Wayland (wl-paste) first, then X11 (xclip)
+    // Сначала Wayland (wl-paste), затем X11 (xclip)
     const commands = [
         `wl-paste --type image/png > "${tmpPath}" 2>/dev/null`,
         `xclip -selection clipboard -t image/png -o > "${tmpPath}" 2>/dev/null`,
@@ -58,45 +82,36 @@ async function readClipboardFallback() {
                 return buf;
         }
         catch {
-            // try next command
+            // пробуем следующую команду
         }
     }
     try {
         unlinkSync(tmpPath);
     }
-    catch { }
+    catch {
+        // Best-effort чистка времянки — зависший файл не должен маскировать null.
+    }
     return null;
 }
 /**
- * Load an image from a file path, resize via Bun.Image, return as JPEG data URL.
- * Target: ~800px wide, JPEG quality 60 — typically 5-15KB (~2-4K tokens).
+ * Грузит картинку из файла, ужимает через Bun.Image, отдаёт JPEG data URL.
+ * Цель: ~800px по ширине, JPEG 60 — обычно 5–15KB (~2–4K токенов).
  */
 export async function loadFileAsDataUrl(filePath) {
     const buf = readFileSync(filePath);
-    // Use Bun.Image if available — resize + convert to JPEG
-    if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
-        try {
-            const img = new Bun.Image(buf);
-            const { width } = await img.metadata();
-            const targetWidth = Math.min(800, width || 800);
-            const dataUrl = await img
-                .resize(targetWidth, 800, { fit: "inside" })
-                .jpeg({ quality: 60 })
-                .dataurl();
-            return { dataUrl };
-        }
-        catch {
-            // Bun.Image failed — fall through to raw base64
-        }
-    }
-    // Fallback: raw base64 (no resize)
+    // Bun.Image, если есть — ресайз + конвертация в JPEG
+    const resized = await resizeToJpegDataUrl(buf);
+    if (resized)
+        return { dataUrl: resized };
+    // Фолбэк: сырой base64 (без ресайза)
     const b64 = buf.toString("base64");
     const ext = filePath.split(".").pop()?.toLowerCase();
     const mime = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : ext === "webp" ? "image/webp" : "image/png";
     return { dataUrl: `data:${mime};base64,${b64}` };
 }
 /**
- * Load an image from a URL, resize, return as JPEG data URL.
+ * Грузит картинку по URL, ужимает, отдаёт JPEG data URL.
+ * @param url URL картинки; @returns data URL.
  */
 export async function loadUrlAsDataUrl(url) {
     const resp = await fetch(url);
@@ -104,44 +119,20 @@ export async function loadUrlAsDataUrl(url) {
         throw new Error(`Failed to fetch image: ${resp.status} ${resp.statusText}`);
     }
     const buf = Buffer.from(await resp.arrayBuffer());
-    if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
-        try {
-            const img = new Bun.Image(buf);
-            const { width } = await img.metadata();
-            const targetWidth = Math.min(800, width || 800);
-            const dataUrl = await img
-                .resize(targetWidth, 800, { fit: "inside" })
-                .jpeg({ quality: 60 })
-                .dataurl();
-            return { dataUrl };
-        }
-        catch {
-            // fall through
-        }
-    }
+    const resized = await resizeToJpegDataUrl(buf);
+    if (resized)
+        return { dataUrl: resized };
     const b64 = buf.toString("base64");
     return { dataUrl: `data:image/png;base64,${b64}` };
 }
 /**
- * Process a clipboard buffer (already resized by readClipboardImage)
- * into a data URL. Used by Ctrl+V handler.
+ * Превращает буфер обмена (уже ужатый readClipboardImage) в data URL.
+ * Нужен обработчику Ctrl+V.
  */
 export async function bufferToDataUrl(buf) {
-    if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
-        try {
-            const img = new Bun.Image(buf);
-            const { width } = await img.metadata();
-            const targetWidth = Math.min(800, width || 800);
-            const dataUrl = await img
-                .resize(targetWidth, 800, { fit: "inside" })
-                .jpeg({ quality: 60 })
-                .dataurl();
-            return { dataUrl };
-        }
-        catch {
-            // fall through
-        }
-    }
+    const resized = await resizeToJpegDataUrl(buf);
+    if (resized)
+        return { dataUrl: resized };
     const b64 = buf.toString("base64");
     return { dataUrl: `data:image/png;base64,${b64}` };
 }

package/dist/llm/llm-errors.js

@@ -1,3 +1,4 @@
+/** Типизированные ошибки LLM-транспорта (terminal/recoverable/status). */
 /**
  * Типизированные ошибки LLM-транспорта.
  *
@@ -30,10 +31,18 @@ export class LlmError extends Error {
         this.recoverable = options.recoverable ?? false;
         this.llmStatus = options.llmStatus;
     }
+    /**
+     * Помечает ошибку терминальной (стрим не ретраится).
+     * @returns this для чейнинга.
+     */
     markTerminal() {
         this.terminal = true;
         return this;
     }
+    /**
+     * Помечает ошибку восстановимой (причину вернуть модели через цикл).
+     * @returns this для чейнинга.
+     */
     markRecoverable() {
         this.recoverable = true;
         return this;

package/dist/llm/model-loader.js

@@ -1,33 +1,7 @@
-/**
- * Ask LM Studio's native API which context length the model is currently
- * loaded with. Prefers the running instance (`loaded_instances[].config.
- * context_length`), falls back to the model's `max_context_length`. Returns
- * null when the endpoint is unavailable (not LM Studio), the model is not
- * found/loaded, or the request fails — the caller must degrade silently.
- */
-export async function getLoadedContextLength(baseUrl, model, timeoutMs = 3000) {
-    const base = baseUrl.replace(/\/$/, "").replace(/\/v1\/?$/, "");
-    try {
-        const response = await fetch(`${base}/api/v1/models`, {
-            signal: AbortSignal.timeout(timeoutMs),
-        });
-        if (!response.ok)
-            return null;
-        const data = (await response.json());
-        const models = data.models || [];
-        const found = models.find((m) => m.key === model || m.name === model || model.includes(m.key));
-        if (!found)
-            return null;
-        const loadedInstance = (found.loaded_instances ?? [])[0];
-        const actual = loadedInstance?.config?.context_length ?? found.max_context_length;
-        if (typeof actual !== "number" || actual <= 0)
-            return null;
-        return { model: found.key ?? found.name ?? model, actual };
-    }
-    catch {
-        return null;
-    }
-}
+// Хелперы живой context-probe — в ./provider-context.ts и ./models-dev.ts;
+// реэкспорт отсюда, чтобы существующие импорты не ломать.
+export { probeModel, getLoadedContextLength, probeProviderContext, } from "./provider-context";
+/** Загрузчик модели LM Studio: ensure + load через native API. */
 export class ModelLoader {
     baseUrl;
     logger;
@@ -36,6 +10,10 @@ export class ModelLoader {
         this.baseUrl = url.replace(/\/v1\/?$/, "");
         this.logger = logger;
     }
+    /**
+     * Гарантирует загруженную модель с нужным контекстом (иначе грузит).
+     * @param config конфиг загрузки; @returns итог (уже была/загружена/ошибка).
+     */
     async ensureModelLoaded(config) {
         if (config.autoLoad === false) {
             return { success: true, alreadyLoaded: true };
@@ -61,11 +39,11 @@ export class ModelLoader {
             if (!response.ok)
                 return false;
             const data = (await response.json());
-            const models = data.models || [];
+            const models = data.models ?? [];
             const found = models.find((m) => m.key === model || m.name === model);
             if (!found)
                 return false;
-            const loadedInstances = found.loaded_instances || [];
+            const loadedInstances = found.loaded_instances ?? [];
             return loadedInstances.some((inst) => inst.config?.context_length === contextLength);
         }
         catch {

package/dist/llm/models-dev.js

@@ -0,0 +1,121 @@
+/**
+ * models.dev-фолбэк для хостед-шлюзов (OpenCode Zen/Go), чей собственный
+ * `/models` отдаёт голые id без метаданных контекста (проверено вживую:
+ * только `{id, object, created, owned_by}`).
+ *
+ * models.dev — открытая база моделей (MIT, sst/models.dev), её же использует
+ * сам opencode. Каталог `api.json`: `Record<providerId, { models:
+ * Record<modelId, { limit: { context } }> }>`, провайдер `opencode` держит
+ * модели под теми же bare id, что отдаёт Zen (`deepseek-v4.1-flash` →
+ * `limit.context`).
+ *
+ * На диске только slim-проекция (`opencode` → id → контекст):
+ * `~/.mma/models-dev-cache.json` (override `MMA_MODELS_DEV_CACHE`), TTL 24h
+ * как у reasoning-пробника. Любой сбой — null, вызывающий хранит настроенный
+ * `contextWindow` (fail-open).
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { globalMmaDir } from "../config/paths";
+import { readEnv } from "../config/env";
+import { MODELS_DEV_CATALOG_TTL_MS, MODELS_DEV_FETCH_TIMEOUT_MS, } from "../config/timeouts";
+const MODELS_DEV_URL = "https://models.dev/api.json";
+function cachePath() {
+    return readEnv("MODELS_DEV_CACHE") ?? join(globalMmaDir(), "models-dev-cache.json");
+}
+/** In-memory L1: свежая проекция на время жизни процесса. */
+let memCache = null;
+function readDiskCache() {
+    try {
+        const path = cachePath();
+        if (!existsSync(path))
+            return null;
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        if (typeof parsed.ts !== "string" || !parsed.models || typeof parsed.models !== "object") {
+            return null;
+        }
+        return { ts: parsed.ts, models: parsed.models };
+    }
+    catch {
+        // Битый кэш — перечитываем ниже.
+        return null;
+    }
+}
+function writeDiskCache(models) {
+    try {
+        const path = cachePath();
+        mkdirSync(dirname(path), { recursive: true });
+        const entry = { ts: new Date().toISOString(), models };
+        writeFileSync(path, JSON.stringify(entry), "utf-8");
+    }
+    catch {
+        // Best-effort — падение записи не должно ронять агента.
+    }
+}
+/** `limit.context` одной записи модели, если это годное число. */
+function modelContextOf(meta) {
+    const context = meta?.limit?.context;
+    if (typeof context !== "number" || !Number.isFinite(context) || context <= 0)
+        return null;
+    return Math.floor(context);
+}
+function extractOpencodeModels(catalog) {
+    if (!catalog || typeof catalog !== "object")
+        return null;
+    const provider = catalog.opencode;
+    if (!provider || typeof provider !== "object")
+        return null;
+    const models = provider.models;
+    if (!models || typeof models !== "object")
+        return null;
+    const out = {};
+    for (const [id, meta] of Object.entries(models)) {
+        const context = modelContextOf(meta);
+        if (context !== null)
+            out[id] = context;
+    }
+    return out;
+}
+async function fetchCatalog(timeoutMs) {
+    try {
+        const response = await fetch(MODELS_DEV_URL, { signal: AbortSignal.timeout(timeoutMs) });
+        if (!response.ok)
+            return null;
+        return extractOpencodeModels((await response.json()));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Ищет `model` в секции провайдера `opencode` каталога models.dev.
+ * Только точное совпадение id (Zen отдаёт bare id, каталог ключует так же).
+ * Возвращает каталожный `limit.context`, на любом промахе — null.
+ */
+export async function lookupModelsDevContext(model, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? MODELS_DEV_FETCH_TIMEOUT_MS;
+    if (memCache && Date.now() - memCache.ts < MODELS_DEV_CATALOG_TTL_MS) {
+        return memCache.models[model] ?? null;
+    }
+    const disk = readDiskCache();
+    if (disk && Date.now() - new Date(disk.ts).getTime() < MODELS_DEV_CATALOG_TTL_MS) {
+        memCache = { models: disk.models, ts: Date.now() };
+        return disk.models[model] ?? null;
+    }
+    const fresh = await fetchCatalog(timeoutMs);
+    if (!fresh) {
+        // Офлайн с протухшим кэшем: протухшее окно лучше никакого.
+        if (disk) {
+            memCache = { models: disk.models, ts: Date.now() };
+            return disk.models[model] ?? null;
+        }
+        return null;
+    }
+    memCache = { models: fresh, ts: Date.now() };
+    writeDiskCache(fresh);
+    return fresh[model] ?? null;
+}
+/** Тестовый шов: сбросить in-memory проекцию (диск изолирован через env). */
+export function resetModelsDevCache() {
+    memCache = null;
+}