micro-models-agent 2.11.0 → 2.13.1

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;
+}

package/dist/llm/openai-compat.js

@@ -6,14 +6,14 @@ import { LlmError } from "./llm-errors";
 import { backoffDelay } from "../utils/retry";
 import { StreamState } from "./stream-state";
 import { parseCacheUsage } from "./cache-usage";
-const REQUEST_TIMEOUT_MS = 120000;
-/** Max wait (ms) for a self-inflicted rate-limit slot before giving up. */
-const MAX_RATE_WAIT_MS = 30_000;
+import { LLM_REQUEST_TIMEOUT_MS as REQUEST_TIMEOUT_MS, LLM_MAX_RATE_WAIT_MS as MAX_RATE_WAIT_MS, } from "../config/timeouts";
+/** Cap completion-токенов в max_tokens, если конфиг не задал. */
+const DEFAULT_MAX_COMPLETION_TOKENS = 8192;
 /**
- * Client identity header. OpenCode Go asks clients to identify themselves with
- * their own user agent (not a generic SDK/HTTP-library name) so requests route
- * to coding-agent traffic. `readMmaVersion()` is memoized — every provider
- * construction would otherwise re-read package.json.
+ * Client identity-заголовок. OpenCode Go просит клиентов представляться своим
+ * user agent (не generic SDK/HTTP-библиотекой), чтобы запросы роутились в
+ * coding-agent трафик. `readMmaVersion()` мемоизирован — иначе каждая сборка
+ * провайдера перечитывала бы package.json.
  */
 let cachedUserAgent = null;
 function defaultUserAgent() {
@@ -21,6 +21,23 @@ function defaultUserAgent() {
         cachedUserAgent = `micro-models-agent/${readMmaVersion()}`;
     return cachedUserAgent;
 }
+/**
+ * Нормализует харнессный уровень reasoning под контракт провайдерского поля
+ * `reasoning_effort` (strict OpenAI/o-series принимает только
+ * low|medium|high). Иначе:
+ * - "default"/undefined → не шлём (решает провайдерский дефолт);
+ * - "none" → не шлём (strict OpenAI отвечает 400; отсутствие поля = не просим
+ *   повышать, а prompt-tag ещё и получает тег /no_think в `chat()`);
+ * - "max" → клампим к "high" (наибольшее валидное значение).
+ * Без нормализации неизвестное значение роняет ВЕСЬ запрос HTTP 400.
+ */
+function normalizeReasoningEffort(level) {
+    if (!level || level === "default" || level === "none")
+        return undefined;
+    if (level === "max")
+        return "high";
+    return level;
+}
 function buildRequestBody(opts) {
     const body = {
         model: opts.model,
@@ -37,21 +54,24 @@ function buildRequestBody(opts) {
         body.session_id = opts.sessionId;
     if (opts.stream && opts.streamUsage)
         body.stream_options = { include_usage: true };
-    // Apply reasoning effort via the provider's strategy
+    // Применяем effort через стратегию провайдера (уровень нормализуется под
+    // контракт OpenAI: low|medium|high).
     const strategy = opts.reasoningStrategy ?? "openai-effort";
-    const level = opts.reasoningEffort;
-    if (strategy === "openai-effort" && level && level !== "default") {
-        body.reasoning_effort = level;
+    const effort = normalizeReasoningEffort(opts.reasoningEffort);
+    if (strategy === "openai-effort") {
+        if (effort)
+            body.reasoning_effort = effort;
     }
     else if (strategy === "template-kwarg") {
-        body.chat_template_kwargs = { enable_thinking: level !== "none" };
+        body.chat_template_kwargs = { enable_thinking: opts.reasoningEffort !== "none" };
     }
-    else if (strategy === "prompt-tag" && level && level !== "default") {
-        // Send reasoning_effort in body (models that respect it via API) AND
-        // add /no_think tag to message (models that only respect prompt signals).
-        body.reasoning_effort = level;
+    else if (strategy === "prompt-tag") {
+        // Шлём reasoning_effort в теле (модели с API-поддержкой) И тег /no_think
+        // в сообщение (модели только с prompt-сигналами; тег ставит `chat()`).
+        if (effort)
+            body.reasoning_effort = effort;
     }
-    // "none" = unsupported, skip
+    // "none" = не поддерживается, пропуск
     if (opts.tools && opts.tools.length > 0) {
         body.tools = opts.tools.map((t) => ({
             type: "function",
@@ -65,6 +85,7 @@ function buildRequestBody(opts) {
     }
     return body;
 }
+/** Провайдер OpenAI-совместимого API (стрим + non-stream фолбэки, ретраи). */
 export class OpenAICompatProvider {
     model;
     contextWindow;
@@ -98,11 +119,16 @@ export class OpenAICompatProvider {
         this.userAgent = config.userAgent ?? defaultUserAgent();
         this.debug = config.logger ? config.logger.debug.bind(config.logger) : null;
     }
+    /**
+     * Стрим чата: rate-limit → стрим → фолбэк non-stream при пустом стриме.
+     * @param messages история; @param tools определения тулов;
+     * @param signal abort; @param options лимит токенов/reasoning.
+     * @returns асинхронный итератор чанков.
+     */
     async *chat(messages, tools, signal, options) {
-        // Check rate limit before making request. A self-inflicted limit should
-        // wait for a slot (bounded) instead of aborting a healthy turn; only if
-        // no slot frees within the window do we surface a recoverable error the
-        // agent loop can feed back (rather than dying).
+        // Проверка лимита до запроса. Собственный лимит ждёт слота (ограниченно),
+        // а не роняет здоровый ход; recoverable-ошибка наружу — только если слот
+        // не освободился в окне (цикл скормит её модели, а не умрёт).
         if (!this.rateLimiter.canMakeRequest()) {
             const waitMs = Math.min(this.rateLimiter.msUntilRequest(), MAX_RATE_WAIT_MS);
             if (waitMs > 0) {
@@ -112,9 +138,9 @@ export class OpenAICompatProvider {
                 throw new LlmError(`Rate limit exceeded: ${this.rateLimiter.getConfig().maxRequestsPerMinute} requests per minute`, { recoverable: true });
             }
         }
-        // Record this request
+        // Фиксируем запрос
         this.rateLimiter.recordRequest();
-        // Apply prompt-tag strategy: append /no_think to last user message (outgoing copy only)
+        // Prompt-tag стратегия: дописать /no_think в последнее user-сообщение (только исходящая копия)
         let effectiveMessages = messages;
         if (options?.reasoningStrategy === "prompt-tag" && options?.reasoningEffort === "none") {
             effectiveMessages = this.applyPromptTag(messages, "/no_think");
@@ -132,12 +158,11 @@ export class OpenAICompatProvider {
                 hasReasoning = true;
             yield chunk;
         }
-        // A stream that ended with reasoning but no text/tool_call means the model
-        // THOUGHT but never produced an answer (observed: qwen3.5-9b in LM Studio
-        // emits reasoning_content then stops). The streamed reasoning was already
-        // delivered; fetch the missing answer via non-streaming. The fallback's
-        // own reasoning chunk is dropped so thinking is not shown twice — no text
-        // was emitted, so there is no duplicate-answer risk.
+        // Стрим кончился на reasoning без текста/tool_call: модель ПОДУМАЛА, но
+        // ответа не дала (наблюдалось: qwen3.5-9b в LM Studio шлёт reasoning_content
+        // и встаёт). Reasoning уже отдан; недостающий ответ добираем non-stream.
+        // Reasoning-чанк фолбэка дропаем, чтобы не показать дважды — текста не было,
+        // риск дубля ответа отсутствует.
         if (!hasToolCall && !hasText) {
             this.debug?.("LLM streaming produced no text/tool_call — falling back to non-streaming");
             const fallback = await this.doNonStreaming(effectiveMessages, tools, signal, options);
@@ -149,17 +174,17 @@ export class OpenAICompatProvider {
             }
         }
     }
-    /** Append a tag to the last user message (outgoing copy, never stored in context). */
+    /** Дописывает тег в последнее user-сообщение (исходящая копия, не в контекст). */
     applyPromptTag(messages, tag) {
         const copy = [...messages];
         for (let i = copy.length - 1; i >= 0; i--) {
             if (copy[i].role === "user") {
                 const msg = { ...copy[i] };
                 if (typeof msg.content === "string") {
-                    msg.content = msg.content + "\n" + tag;
+                    msg.content = `${msg.content}\n${tag}`;
                 }
                 else {
-                    // Array of parts — append a text part
+                    // Массив частей — дописываем текстовую часть
                     msg.content = [...msg.content, { type: "text", text: tag }];
                 }
                 copy[i] = msg;
@@ -172,6 +197,7 @@ export class OpenAICompatProvider {
         const { baseDelay, maxDelay, maxStreamRetries, noDataTimeoutMs } = this.retryConfig;
         const streamRetries = maxStreamRetries ?? 2;
         const idleTimeoutMs = noDataTimeoutMs ?? 180000;
+        let usedNonStreamingFallback = false;
         for (let attempt = 0;; attempt++) {
             let emitted = false;
             const onEmit = () => {
@@ -179,27 +205,44 @@ export class OpenAICompatProvider {
             };
             try {
                 const sawDone = yield* this.streamOnce(messages, tools, signal, options, onEmit, idleTimeoutMs);
-                // Clean [DONE] or any partial content → deliver what we have.
+                // Чистый [DONE] или частичный контент — отдаём что есть.
                 if (sawDone || emitted)
                     return;
-                // Stream closed before [DONE] with zero content → retryable truncation.
+                // Стрим закрылся до [DONE] с нулевым контентом — ретраябельная обрезка.
                 if (attempt >= streamRetries)
                     return;
             }
             catch (err) {
                 if (err?.name === "AbortError" || (err instanceof LlmError && err.terminal) || signal?.aborted)
                     throw err;
-                // Content was already delivered — a re-stream would duplicate chunks.
+                // Stall буферизованного SSE после tool_call-дельт: один раз переспрашиваем
+                // non-stream. Стрим тут — битый путь, повтор тем же способом снова
+                // встанет; а tool_call агент получить обязан.
+                if (err?.stalledAfterToolCall === true && !usedNonStreamingFallback) {
+                    usedNonStreamingFallback = true;
+                    this.debug?.("LLM stream stalled after tool_call — falling back to non-streaming request");
+                    const fallback = await this.doNonStreaming(messages, tools, signal, options);
+                    this.debug?.("LLM non-streaming fallback result", { chunks: fallback.length });
+                    for (const chunk of fallback) {
+                        // Reasoning до stall уже, вероятно, устримлен; копию фолбэка дропаем,
+                        // чтобы не дублировать мышление.
+                        if (chunk.type === "reasoning")
+                            continue;
+                        yield chunk;
+                    }
+                    return;
+                }
+                // Контент уже отдан — перестрим продублировал бы чанки.
                 if (emitted || attempt >= streamRetries)
                     throw err;
-                // Connection dropped before any content → retry the whole request.
+                // Обрыв до любого контента — переспрашиваем целиком.
             }
             // Экспоненциальный backoff с джиттером (общий хелпер из src/utils).
             await this.sleep(backoffDelay(attempt, baseDelay, maxDelay, 0.1), signal);
         }
     }
     async *streamOnce(messages, tools, signal, options, onEmit, idleTimeoutMs) {
-        const maxTokens = options?.maxTokens ?? this.config.maxCompletionTokens ?? 4096;
+        const maxTokens = options?.maxTokens ?? this.config.maxCompletionTokens ?? DEFAULT_MAX_COMPLETION_TOKENS;
         const body = buildRequestBody({
             model: this.model,
             messages,
@@ -231,8 +274,8 @@ export class OpenAICompatProvider {
             });
         }
         catch (err) {
-            // Fetch-level failures are already HTTP-retried inside fetchWithRetry —
-            // don't double-retry them at the stream level.
+            // Fetch-сбои уже HTTP-ретраятся внутри fetchWithRetry —
+            // на уровне стрима повторно не ретраим.
             if (err?.name === "AbortError")
                 throw err;
             const wrapped = err instanceof Error ? err : new Error(String(err));
@@ -266,6 +309,14 @@ export class OpenAICompatProvider {
         const toolCallAccs = new Map();
         // Единый контейнер состояния стрима (вместо 9 разрозненных флагов).
         const st = new StreamState();
+        // Stall после старта tool_call-дельт обычно значит: провайдер буферизует
+        // SSE вместо стрима дельт аргументов (видели на LM Studio). Помечаем ошибку,
+        // чтобы `doStream` переспросил non-stream вместо провала всего прогона.
+        const idleError = () => {
+            const e = new Error(t(st.sawToolCallStart ? "error.llm_stream_idle_toolcall" : "error.llm_stream_idle", { timeout: idleTimeoutMs }));
+            e.stalledAfterToolCall = st.sawToolCallStart;
+            return e;
+        };
         const readIdle = () => new Promise((resolve, reject) => {
             const idleTimer = setTimeout(() => {
                 flagTimeout();
@@ -274,13 +325,13 @@ export class OpenAICompatProvider {
             reader.read().then((result) => {
                 clearTimeout(idleTimer);
                 if (isTimeout())
-                    reject(new Error(t(st.sawToolCallStart ? "error.llm_stream_idle_toolcall" : "error.llm_stream_idle", { timeout: idleTimeoutMs })));
+                    reject(idleError());
                 else
                     resolve(result);
             }, (err) => {
                 clearTimeout(idleTimer);
                 if (isTimeout())
-                    reject(new Error(t(st.sawToolCallStart ? "error.llm_stream_idle_toolcall" : "error.llm_stream_idle", { timeout: idleTimeoutMs })));
+                    reject(idleError());
                 else
                     reject(err);
             });
@@ -306,10 +357,9 @@ export class OpenAICompatProvider {
                         }
                     }
                     else {
-                        // Not SSE-framed — Ollama (and some other backends) may stream
-                        // NDJSON or send mid-stream errors as bare JSON. Try to parse the
-                        // raw line; unparseable noise (SSE comments, keep-alives) is
-                        // counted and skipped.
+                        // Не SSE-фрейм — Ollama (и часть бэкендов) стримят NDJSON или шлют
+                        // mid-stream ошибки голым JSON. Пробуем парсить сырую строку;
+                        // непарсящийся шум (SSE-комменты, keep-alive) считаем и пропускаем.
                         st.nonDataLines++;
                         if (st.nonDataSamples.length < 5)
                             st.nonDataSamples.push(trimmed.slice(0, 200));
@@ -320,7 +370,7 @@ export class OpenAICompatProvider {
                         st.parsedChunks++;
                         const choice = parsed.choices?.[0];
                         if (!choice) {
-                            // Usage comes in the last chunk with empty choices
+                            // Usage приходит в последнем чанке с пустыми choices
                             if (parsed.usage) {
                                 st.usage = {
                                     promptTokens: parsed.usage.prompt_tokens ?? 0,
@@ -331,14 +381,14 @@ export class OpenAICompatProvider {
                                 this.debug?.("LLM stream usage", { ...st.usage });
                             }
                             else if (parsed.error) {
-                                // Mid-stream provider error (Ollama sends {"error": "..."} as
-                                // bare JSON once generation already started). Surface it —
-                                // swallowing it makes the response look silently empty.
-                                // Thrown OUTSIDE the JSON-parse try/catch below.
+                                // Mid-stream ошибка провайдера (Ollama шлёт {"error": "..."}
+                                // голым JSON после старта генерации). Показываем — глотание
+                                // даст молча пустой ответ.
+                                // Брошено ВНЕ try/catch JSON-парсинга ниже.
                                 st.midStreamError = String(parsed.error);
                             }
-                            // NOTE: no `continue` here — it would skip the midStreamError
-                            // throw below (which lives outside this try/catch).
+                            // NOTE: `continue` тут нет — он пропустил бы throw midStreamError
+                            // ниже (он вне этого try/catch).
                         }
                         else {
                             if (st.parsedChunks <= 3 || st.parsedChunks % 50 === 0) {
@@ -353,7 +403,7 @@ export class OpenAICompatProvider {
                             const finishReason = choice.finish_reason;
                             if (finishReason)
                                 st.lastFinishReason = finishReason;
-                            // `reasoning` is the Ollama alias for OpenAI's `reasoning_content`.
+                            // `reasoning` — алиас Ollama для openai-`reasoning_content`.
                             const reasoningDelta = delta.reasoning_content ?? delta.reasoning;
                             if (reasoningDelta) {
                                 onEmit();
@@ -400,7 +450,7 @@ export class OpenAICompatProvider {
                         }
                     }
                     catch {
-                        // Skip malformed JSON lines
+                        // Битые JSON-строки пропускаем
                     }
                     if (st.midStreamError) {
                         throw new Error(t("error.llm_provider_stream_error", { error: st.midStreamError.slice(0, 300) }));
@@ -411,10 +461,10 @@ export class OpenAICompatProvider {
                 onEmit();
                 yield { type: "done", usage: st.usage };
             }
-            // finish_reason "length": the completion hit the token limit. An
-            // unfinished tool_call would otherwise be silently swallowed (tool_calls
-            // are only yielded on finish_reason "tool_calls") and surface as an
-            // empty response → blind hallucination retries. Surface the real cause.
+            // finish_reason "length": completion упёрся в лимит токенов. Незаконченный
+            // tool_call иначе молча глотается (tool_calls отдаются только на
+            // finish_reason "tool_calls") и всплывает пустым ответом → слепые
+            // hallucination-ретраи. Показываем настоящую причину.
             if (st.lastFinishReason === "length") {
                 const truncatedToolCall = st.sawToolCallStart && toolCallAccs.size > 0;
                 if (truncatedToolCall || !st.sawText) {
@@ -454,14 +504,14 @@ export class OpenAICompatProvider {
             streamUsage: this.cache?.requestStreamUsage === true,
         };
     }
-    /** Shared request setup: auth headers + timeout/abort controller wiring. */
+    /** Общая подготовка запроса: auth-заголовки + таймаут/abort-контроллер. */
     buildRequestSetup(signal) {
         const headers = {
             "Content-Type": "application/json",
             "User-Agent": this.userAgent,
         };
         if (this.config.apiKey && this.config.apiKey !== "not-needed") {
-            headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+            headers.Authorization = `Bearer ${this.config.apiKey}`;
         }
         const sessionId = this.getSessionId?.();
         // Когда capability задана — шлём заголовок только тем, кому он нужен
@@ -500,7 +550,7 @@ export class OpenAICompatProvider {
         };
     }
     async doNonStreaming(messages, tools, signal, options) {
-        const maxTokens = options?.maxTokens ?? this.config.maxCompletionTokens ?? 4096;
+        const maxTokens = options?.maxTokens ?? this.config.maxCompletionTokens ?? DEFAULT_MAX_COMPLETION_TOKENS;
         const body = buildRequestBody({
             model: this.model,
             messages,
@@ -528,7 +578,7 @@ export class OpenAICompatProvider {
                 }));
             }
             const data = await response.json();
-            // Some backends (e.g. Ollama) return HTTP 200 with {"error": "..."}.
+            // Часть бэкендов (напр. Ollama) отдают HTTP 200 с {"error": "..."}.
             if (data.error && !data.choices) {
                 throw new Error(t("error.llm_provider_stream_error", { error: String(data.error).slice(0, 300) }));
             }
@@ -557,15 +607,15 @@ export class OpenAICompatProvider {
                     });
                 }
             }
-            // Completed text but hit the cap: surface a visible warning instead of
-            // silently accepting a cut-off answer (see the streaming path).
+            // Текст готов, но упёрся в cap: видимый warning вместо молча
+            // принятого обрезанного ответа (см. стрим-путь).
             if (choice.finish_reason === "length" && msg.content && !msg.tool_calls) {
                 chunks.push({
                     type: "warning",
                     content: t("error.llm_output_truncated", { tokens: maxTokens }),
                 });
             }
-            // Append usage from API response
+            // Дописываем usage из ответа API
             if (data.usage) {
                 chunks.push({
                     type: "done",
@@ -589,9 +639,17 @@ export class OpenAICompatProvider {
             cleanup();
         }
     }
+    /**
+     * Считает токены текста (tiktoken по дефолтной модели).
+     * @param text текст; @returns число токенов.
+     */
     countTokens(text) {
         return this.tokenCounter.count(text);
     }
+    /**
+     * Список моделей провайдера (`/models`: id/name/model).
+     * @returns имена моделей; @throws при недоступности провайдера.
+     */
     async listModels() {
         try {
             const url = `${this.config.baseUrl.replace(/\/+$/, "")}/models`;
@@ -600,20 +658,35 @@ export class OpenAICompatProvider {
                 "User-Agent": this.userAgent,
             };
             if (this.config.apiKey && this.config.apiKey !== "not-needed") {
-                headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+                headers.Authorization = `Bearer ${this.config.apiKey}`;
             }
             const response = await fetch(url, {
                 method: "GET",
                 headers,
             });
             if (!response.ok) {
-                // Surface the failure: health probes must distinguish a dead
-                // provider from one that serves an empty model list.
+                // Провал наружу: health-пробы должны отличать мёртвый провайдер
+                // от пустого списка моделей.
                 throw new Error(`HTTP ${response.status} from ${url}`);
             }
-            const data = (await response.json());
-            const models = (data.data || data || [])
-                .map((m) => m.id || m.name || m.model || "")
+            const data = await response.json();
+            const rawList = Array.isArray(data)
+                ? data
+                : data && typeof data === "object" && Array.isArray(data.data)
+                    ? data.data
+                    : [];
+            const models = rawList
+                .map((m) => {
+                if (m && typeof m === "object") {
+                    const obj = m;
+                    for (const key of ["id", "name", "model"]) {
+                        const v = obj[key];
+                        if (typeof v === "string" && v)
+                            return v;
+                    }
+                }
+                return "";
+            })
                 .filter(Boolean);
             return models;
         }
@@ -643,8 +716,8 @@ export class OpenAICompatProvider {
                     throw err;
             }
             if (attempt < maxRetries) {
-                // Prefer the provider's Retry-After window (saturating at maxDelay);
-                // otherwise exponential backoff. 429s from free tiers need a real wait.
+                // Приоритет окну Retry-After провайдера (cap на maxDelay); иначе —
+                // экспоненциальный backoff. 429 с free-тарифов требуют реального ожидания.
                 const delay = lastRetryAfter > 0
                     ? Math.min(lastRetryAfter, maxDelay)
                     : backoffDelay(attempt, baseDelay, maxDelay, 0.1);