micro-models-agent 0.51.1 → 0.52.0

package/dist/llm/openai-compat.js

@@ -1,6 +1,7 @@
 import { TokenCounter } from "./token-counter";
 import { t } from "../i18n/index";
 import { createRateLimiter } from "../modules/security/rate-limiter";
+const REQUEST_TIMEOUT_MS = 120000;
 function buildRequestBody(opts) {
     const body = {
         model: opts.model,
@@ -41,6 +42,8 @@ export class OpenAICompatProvider {
             maxRetries: 3,
             baseDelay: 1000,
             maxDelay: 30000,
+            maxStreamRetries: 2,
+            noDataTimeoutMs: 180000,
         };
         this.rateLimiter = createRateLimiter(config.rateLimits);
     }
@@ -54,15 +57,11 @@ export class OpenAICompatProvider {
         const streamResult = this.doStream(messages, tools, signal, options);
         let hasToolCall = false;
         let hasText = false;
-        let reasoningAcc = "";
         for await (const chunk of streamResult) {
             if (chunk.type === "tool_call")
                 hasToolCall = true;
             if (chunk.type === "text")
                 hasText = true;
-            if (chunk.type === "reasoning" && chunk.content) {
-                reasoningAcc += chunk.content;
-            }
             yield chunk;
         }
         if (!hasToolCall && !hasText) {
@@ -73,63 +72,114 @@ export class OpenAICompatProvider {
         }
     }
     async *doStream(messages, tools, signal, options) {
+        const { baseDelay, maxDelay, maxStreamRetries, noDataTimeoutMs } = this.retryConfig;
+        const streamRetries = maxStreamRetries ?? 2;
+        const idleTimeoutMs = noDataTimeoutMs ?? 180000;
+        for (let attempt = 0;; attempt++) {
+            let emitted = false;
+            const onEmit = () => {
+                emitted = true;
+            };
+            try {
+                const sawDone = yield* this.streamOnce(messages, tools, signal, options, onEmit, idleTimeoutMs);
+                // Clean [DONE] or any partial content → deliver what we have.
+                if (sawDone || emitted)
+                    return;
+                // Stream closed before [DONE] with zero content → retryable truncation.
+                if (attempt >= streamRetries)
+                    return;
+            }
+            catch (err) {
+                if (err?.name === "AbortError" || err?.llmTerminal || signal?.aborted)
+                    throw err;
+                // Content was already delivered — a re-stream would duplicate chunks.
+                if (emitted || attempt >= streamRetries)
+                    throw err;
+                // Connection dropped before any content → retry the whole request.
+            }
+            const delay = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+            const jitter = Math.random() * baseDelay * 0.1;
+            await this.sleep(delay + jitter, signal);
+        }
+    }
+    async *streamOnce(messages, tools, signal, options, onEmit, idleTimeoutMs) {
+        const maxTokens = options?.maxTokens ?? this.config.maxCompletionTokens ?? 4096;
         const body = buildRequestBody({
             model: this.model,
             messages,
             tools,
             stream: true,
-            maxTokens: options?.maxTokens ?? this.config.maxCompletionTokens ?? 4096,
+            maxTokens,
             reasoningEffort: options?.reasoningEffort,
         });
-        const headers = {
-            "Content-Type": "application/json",
-        };
-        if (this.config.apiKey && this.config.apiKey !== "not-needed") {
-            headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+        const { headers, abortSignal, cleanup, isTimeout, flagTimeout, controller } = this.buildRequestSetup(signal);
+        let response;
+        try {
+            response = await this.fetchWithRetry(`${this.config.baseUrl}/chat/completions`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(body),
+                signal: abortSignal,
+            });
+        }
+        catch (err) {
+            // Fetch-level failures are already HTTP-retried inside fetchWithRetry —
+            // don't double-retry them at the stream level.
+            if (err?.name === "AbortError")
+                throw err;
+            const wrapped = err instanceof Error ? err : new Error(String(err));
+            wrapped.llmTerminal = true;
+            throw wrapped;
         }
-        const controller = new AbortController();
-        const totalTimeoutMs = 120000;
-        const timeoutId = setTimeout(() => controller.abort(), totalTimeoutMs);
-        const abortSignal = (() => {
-            if (!signal)
-                return controller.signal;
-            try {
-                return AbortSignal.any([controller.signal, signal]);
-            }
-            catch {
-                signal.addEventListener("abort", () => controller.abort(), {
-                    once: true,
-                });
-                return controller.signal;
-            }
-        })();
-        const response = await this.fetchWithRetry(`${this.config.baseUrl}/chat/completions`, {
-            method: "POST",
-            headers,
-            body: JSON.stringify(body),
-            signal: abortSignal,
-        });
         if (!response.ok) {
-            clearTimeout(timeoutId);
+            cleanup();
             const errorText = await response.text();
-            throw new Error(t("error.llm_api", {
+            const err = new Error(t("error.llm_api", {
                 status: response.status,
                 statusText: response.statusText,
                 errorText,
             }));
+            err.llmTerminal = true;
+            throw err;
         }
         const reader = response.body?.getReader();
         if (!reader) {
-            clearTimeout(timeoutId);
+            cleanup();
             throw new Error(t("error.no_response_body"));
         }
         const decoder = new TextDecoder();
         let buffer = "";
         const toolCallAccs = new Map();
+        // A tool_call started accumulating — the server committed to a response.
+        // If the stream stalls after this, the provider most likely buffers SSE
+        // instead of streaming argument deltas (seen with LM Studio).
+        let sawToolCallStart = false;
         let usage;
+        let sawDone = false;
+        let lastFinishReason;
+        let sawText = false;
+        const readIdle = () => new Promise((resolve, reject) => {
+            const idleTimer = setTimeout(() => {
+                flagTimeout();
+                controller.abort();
+            }, idleTimeoutMs);
+            reader.read().then((result) => {
+                clearTimeout(idleTimer);
+                if (isTimeout())
+                    reject(new Error(t(sawToolCallStart ? "error.llm_stream_idle_toolcall" : "error.llm_stream_idle", { timeout: idleTimeoutMs })));
+                else
+                    resolve(result);
+            }, (err) => {
+                clearTimeout(idleTimer);
+                if (isTimeout())
+                    reject(new Error(t(sawToolCallStart ? "error.llm_stream_idle_toolcall" : "error.llm_stream_idle", { timeout: idleTimeoutMs })));
+                else
+                    reject(err);
+            });
+        });
         try {
             while (true) {
-                const { done, value } = await reader.read();
+                const { done, value } = await readIdle();
                 if (done)
                     break;
                 buffer += decoder.decode(value, { stream: true });
@@ -140,8 +190,10 @@ export class OpenAICompatProvider {
                     if (!trimmed || !trimmed.startsWith("data: "))
                         continue;
                     const data = trimmed.slice(6);
-                    if (data === "[DONE]")
+                    if (data === "[DONE]") {
+                        sawDone = true;
                         continue;
+                    }
                     try {
                         const parsed = JSON.parse(data);
                         const choice = parsed.choices?.[0];
@@ -158,10 +210,14 @@ export class OpenAICompatProvider {
                         }
                         const delta = choice.delta || {};
                         const finishReason = choice.finish_reason;
+                        if (finishReason)
+                            lastFinishReason = finishReason;
                         if (delta.reasoning_content) {
+                            onEmit();
                             yield { type: "reasoning", content: delta.reasoning_content };
                         }
                         if (delta.tool_calls) {
+                            sawToolCallStart = true;
                             for (const tc of delta.tool_calls) {
                                 const idx = tc.index ?? 0;
                                 if (!toolCallAccs.has(idx)) {
@@ -178,11 +234,14 @@ export class OpenAICompatProvider {
                             }
                         }
                         if (delta.content) {
+                            onEmit();
+                            sawText = true;
                             yield { type: "text", content: delta.content };
                         }
                         if (finishReason === "tool_calls" && toolCallAccs.size > 0) {
                             for (const [, acc] of toolCallAccs) {
                                 if (acc.name) {
+                                    onEmit();
                                     yield {
                                         type: "tool_call",
                                         toolCall: {
@@ -202,13 +261,71 @@ export class OpenAICompatProvider {
                 }
             }
             if (usage) {
+                onEmit();
                 yield { type: "done", 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.
+            if (lastFinishReason === "length") {
+                const truncatedToolCall = sawToolCallStart && toolCallAccs.size > 0;
+                if (truncatedToolCall || !sawText) {
+                    const err = new Error(t(truncatedToolCall ? "error.llm_truncated_toolcall" : "error.llm_truncated", {
+                        tokens: maxTokens,
+                    }));
+                    err.llmTerminal = true;
+                    // The provider is fine — the model just overran the completion
+                    // limit. The agent loop feeds this back so the model can adapt
+                    // (split the output) instead of the session dying.
+                    err.recoverableLlm = true;
+                    throw err;
+                }
+            }
         }
         finally {
-            clearTimeout(timeoutId);
+            cleanup();
             reader.releaseLock();
         }
+        return sawDone;
+    }
+    /** Shared request setup: auth headers + timeout/abort controller wiring. */
+    buildRequestSetup(signal) {
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        if (this.config.apiKey && this.config.apiKey !== "not-needed") {
+            headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+        }
+        const controller = new AbortController();
+        let timedOut = false;
+        const timeoutId = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, REQUEST_TIMEOUT_MS);
+        const abortSignal = (() => {
+            if (!signal)
+                return controller.signal;
+            try {
+                return AbortSignal.any([controller.signal, signal]);
+            }
+            catch {
+                signal.addEventListener("abort", () => controller.abort(), {
+                    once: true,
+                });
+                return controller.signal;
+            }
+        })();
+        return {
+            headers,
+            abortSignal,
+            cleanup: () => clearTimeout(timeoutId),
+            isTimeout: () => timedOut,
+            flagTimeout: () => {
+                timedOut = true;
+            },
+            controller,
+        };
     }
     async doNonStreaming(messages, tools, signal, options) {
         const body = buildRequestBody({
@@ -219,18 +336,13 @@ export class OpenAICompatProvider {
             maxTokens: options?.maxTokens ?? this.config.maxCompletionTokens ?? 4096,
             reasoningEffort: options?.reasoningEffort,
         });
-        const headers = {
-            "Content-Type": "application/json",
-        };
-        if (this.config.apiKey && this.config.apiKey !== "not-needed") {
-            headers["Authorization"] = `Bearer ${this.config.apiKey}`;
-        }
+        const { headers, abortSignal, cleanup, isTimeout } = this.buildRequestSetup(signal);
         try {
             const response = await this.fetchWithRetry(`${this.config.baseUrl}/chat/completions`, {
                 method: "POST",
                 headers,
                 body: JSON.stringify(body),
-                signal,
+                signal: abortSignal,
             });
             if (!response.ok) {
                 const errorText = await response.text();
@@ -279,8 +391,14 @@ export class OpenAICompatProvider {
             return chunks;
         }
         catch (err) {
+            if (isTimeout() && err?.name === "AbortError") {
+                throw new Error(t("error.llm_timeout", { timeout: REQUEST_TIMEOUT_MS }));
+            }
             throw err instanceof Error ? err : new Error(String(err));
         }
+        finally {
+            cleanup();
+        }
     }
     countTokens(text) {
         return this.tokenCounter.count(text);
@@ -299,7 +417,9 @@ export class OpenAICompatProvider {
                 headers,
             });
             if (!response.ok) {
-                return [];
+                // Surface the failure: health probes must distinguish a dead
+                // provider from one that serves an empty model list.
+                throw new Error(`HTTP ${response.status} from ${url}`);
             }
             const data = (await response.json());
             const models = (data.data || data || [])
@@ -307,33 +427,51 @@ export class OpenAICompatProvider {
                 .filter(Boolean);
             return models;
         }
-        catch {
-            return [];
+        catch (err) {
+            throw err instanceof Error ? err : new Error(String(err));
         }
     }
     async fetchWithRetry(url, init) {
         const { maxRetries, baseDelay, maxDelay } = this.retryConfig;
-        let lastError = null;
+        let lastStatus = 0;
+        let lastRetryAfter = 0;
         for (let attempt = 0; attempt <= maxRetries; attempt++) {
             try {
                 const response = await fetch(url, init);
                 if (!this.isRetryable(response.status))
                     return response;
-                lastError = new Error(`HTTP ${response.status}: ${response.statusText}`);
+                lastStatus = response.status;
+                const retryAfter = Number(response.headers.get("retry-after") ?? 0);
+                lastRetryAfter = retryAfter > 0 ? retryAfter * 1000 : 0;
             }
             catch (err) {
                 if (err.name === "AbortError") {
                     throw err;
                 }
-                lastError = err;
+                if (attempt === maxRetries)
+                    throw err;
             }
             if (attempt < maxRetries) {
-                const delay = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+                // Prefer the provider's Retry-After window (saturating at maxDelay);
+                // otherwise exponential backoff. 429s from free tiers need a real wait.
+                const delay = lastRetryAfter > 0
+                    ? Math.min(lastRetryAfter, maxDelay)
+                    : Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
                 const jitter = Math.random() * baseDelay * 0.1;
                 await this.sleep(delay + jitter, init.signal ?? undefined);
             }
         }
-        throw lastError ?? new Error(t("error.llm_retries"));
+        if (lastStatus === 429) {
+            const e429 = new Error(t("error.llm_429", {
+                model: this.model,
+                baseUrl: this.config.baseUrl,
+            }));
+            e429.llmStatus = lastStatus;
+            throw e429;
+        }
+        const eRetry = new Error(t("error.llm_retries"));
+        eRetry.llmStatus = lastStatus;
+        throw eRetry;
     }
     isRetryable(status) {
         return status === 429 || status >= 500;

package/dist/llm/orchestrator.js

@@ -1,4 +1,4 @@
-import { OpenAICompatProvider } from "./openai-compat";
+import { createProvider } from "../modules/providers/create";
 import { jsonrepair } from "jsonrepair";
 const PLAN_SYSTEM_PROMPT = `You are a planning assistant for an agent system with multiple expert sub-agents.
 Break down the user's task into subtasks that can be executed by different expert agents.
@@ -56,10 +56,11 @@ export class OrchestratorClient {
         this.config = config;
         if (config.model) {
             if (config.provider) {
-                this.provider = new OpenAICompatProvider({
+                this.provider = createProvider(config.provider.type ?? "openai-compat", {
                     model: config.model,
                     baseUrl: config.provider.baseUrl || "http://localhost:1234/v1",
                     apiKey: config.provider.apiKey,
+                    contextWindow: 32768,
                     retry: config.retry,
                 });
             }
@@ -67,9 +68,10 @@ export class OrchestratorClient {
                 this.provider = defaultProvider;
             }
             else {
-                this.provider = new OpenAICompatProvider({
+                this.provider = createProvider("openai-compat", {
                     model: config.model,
                     baseUrl: "http://localhost:1234/v1",
+                    contextWindow: 32768,
                     retry: config.retry,
                 });
             }

package/dist/logger/app-logger.js

@@ -59,19 +59,19 @@ export class Logger {
     }
     // --- Tagged helpers (legacy v1 API) ---
     logLLMRequest(model, messagesCount, promptPreview, caller) {
-        this.fileLog.logLLMRequest(model, messagesCount, promptPreview, caller);
+        this.fileLog.logLLMRequest(model, messagesCount, sanitizeLogMessage(promptPreview), caller);
     }
     logLLMResponse(model, responseLength, genTimeMs, error, caller) {
         this.fileLog.logLLMResponse(model, responseLength, genTimeMs, error, caller);
     }
     logToolCall(tool, preview, result) {
-        this.fileLog.logToolCall(tool, preview, result);
+        this.fileLog.logToolCall(tool, sanitizeLogMessage(preview), result !== undefined ? sanitizeLogMessage(result) : undefined);
     }
     logToolOutput(tool, output, exitCode) {
-        this.fileLog.logToolOutput(tool, output, exitCode);
+        this.fileLog.logToolOutput(tool, sanitizeLogMessage(output), exitCode);
     }
     logREPL(tag, content) {
-        this.fileLog.logREPL(tag, content);
+        this.fileLog.logREPL(tag, sanitizeLogMessage(content));
     }
     child(prefix) {
         const childLogger = new Logger(this.level, this.prefix ? `${this.prefix}:${prefix}` : prefix);
@@ -140,4 +140,50 @@ export class Logger {
         }
         return sanitized;
     }
+    /**
+     * Write a structured record to app.jsonl only (no console / .log output).
+     * Used for machine-readable reports (environment, etc.) that would be too
+     * noisy on the terminal but are valuable for cross-device diagnosis.
+     */
+    logStructured(type, data) {
+        const logTarget = this.sessionDir ?? this.logDir;
+        if (!logTarget)
+            return;
+        try {
+            appendFileSync(join(logTarget, "app.jsonl"), JSON.stringify({
+                level: "info",
+                ts: new Date().toISOString(),
+                type,
+                meta: this.sanitizeMeta(data),
+            }) + "\n", "utf-8");
+        }
+        catch {
+            /* file logging is best-effort */
+        }
+    }
+    /**
+     * Write a log entry to app.jsonl only — no console output, no .log file.
+     * Use this for noisy subsystems (LSP, probes) whose warnings should be
+     * diagnosable from session files but not pollute the user's terminal.
+     */
+    logSilent(level, msg, meta) {
+        const logTarget = this.sessionDir ?? this.logDir;
+        if (!logTarget)
+            return;
+        const ts = new Date().toISOString();
+        const sanitizedMsg = sanitizeLogMessage(msg);
+        const sanitizedMeta = meta ? this.sanitizeMeta(meta) : undefined;
+        try {
+            appendFileSync(join(logTarget, "app.jsonl"), JSON.stringify({
+                level,
+                ts,
+                prefix: this.prefix,
+                msg: sanitizedMsg,
+                meta: sanitizedMeta ?? null,
+            }) + "\n", "utf-8");
+        }
+        catch {
+            /* file logging is best-effort */
+        }
+    }
 }