micro-models-agent 0.63.3 → 1.1.0

package/dist/ui/renderer.js

@@ -1,10 +1,10 @@
 import { pc } from "./colors";
 import { FormattingStream } from "./md-formatter";
 import { Spinner } from "./spinner";
-import { box, divider } from "./box";
 import { getTerminalWidth } from "./table";
 import { t } from "../i18n/index";
 import { formatCost } from "../modules/pricing/prices";
+import { getDefaultChannel } from "../output";
 import { isAbsolute, relative, sep } from "path";
 function formatUsd(cost) {
     return formatCost(cost);
@@ -30,8 +30,9 @@ function toDisplayPath(baseDir, p) {
     return rel.split(sep).join("/");
 }
 const GUTTER = "  ";
-/** Tools that show a busy spinner while running (inline mode). */
-const BUSY_TOOLS = new Set(["lsp_check"]);
+const MAX_OUTPUT_LINES = 50;
+/** Tools that must NOT get a busy spinner — they block on a user prompt. */
+const SPINNERLESS_TOOLS = new Set(["question", "approve"]);
 /** opencode-like leading marker per tool category. */
 export function toolMarker(tool) {
     switch (tool) {
@@ -77,53 +78,65 @@ function friendlyTool(tool) {
     return value !== key ? value : tool;
 }
 /**
- * Streams agent events to the terminal. Rich mode (TTY) adds a spinner
- * and boxed tool cards; plain mode falls back to simple prefixed lines.
+ * Streams agent events to the terminal. Rich mode (TTY) adds a spinner;
+ * plain mode falls back to simple prefixed lines.
  * Colors come from `colors.ts`, disabled outside a TTY, in CI, or on NO_COLOR.
  */
 export class Renderer {
     rich;
     spinner;
     fmt;
-    out;
-    err;
+    channel;
     width;
-    toolStyle;
     baseDir;
     card = null;
+    thoughtStarted = false;
+    thoughtStartMs = 0;
+    thoughtHeaderPrinted = false;
+    textStarted = false;
+    outputLineCount = 0;
+    outputSuppressed = false;
     constructor(opts = {}) {
         this.rich = opts.rich ?? isRichTerminal();
-        this.out = opts.out ?? process.stdout;
-        this.err = opts.err ?? process.stderr;
         this.width = opts.width ?? getTerminalWidth();
-        this.toolStyle = opts.toolStyle ?? "inline";
         this.baseDir = opts.baseDir;
+        this.channel = opts.channel ?? getDefaultChannel();
         this.spinner = new Spinner({
             enabled: this.rich && (opts.spinner ?? true),
-            stream: this.err,
+            channel: this.channel,
             width: this.width,
         });
-        this.fmt = new FormattingStream((line) => this.out.write(`${line}\n`), this.width);
+        this.fmt = new FormattingStream((line) => this.channel.writeRaw(`${line}\n`), this.width, (text) => this.channel.writeRaw(text), { reservedCols: 2, streamPartials: this.rich });
+    }
+    /** Show a thinking spinner while waiting for LLM response. */
+    showLoader() {
+        this.spinner.start(t("ui.thinking"));
     }
     /** Final answer streamed from the model (markdown-formatted). */
     text(chunk) {
         this.endCard();
         this.spinner.stop();
+        if (!this.textStarted) {
+            this.textStarted = true;
+            this.channel.writeRaw(`\n${pc.dim("-")} `);
+        }
         this.fmt.write(chunk);
     }
     /** Arbitrary status/meta text (tool output, reasoning, MoE status). */
     meta(chunk) {
         this.spinner.stop();
-        if (this.card) {
-            if (this.toolStyle === "inline") {
-                this.writeInlineBody(chunk);
-            }
-            else {
-                this.card.body.push(chunk);
+        if (this.thoughtStarted) {
+            if (!this.thoughtHeaderPrinted) {
+                this.channel.writeRaw(`\n${pc.dim("→")} Thought: `);
+                this.thoughtHeaderPrinted = true;
             }
+            this.channel.writeRaw(pc.dim(chunk));
+        }
+        else if (this.card) {
+            this.writeInlineBody(chunk);
         }
         else {
-            this.out.write(chunk);
+            this.channel.writeRaw(chunk);
         }
     }
     /** Stream tool body lines with the gutter prefix, skipping blank lines. */
@@ -131,76 +144,79 @@ export class Renderer {
         for (const line of chunk.split("\n")) {
             if (line.trim() === "")
                 continue;
-            this.out.write(`${GUTTER}${line}\n`);
+            this.outputLineCount++;
+            if (this.outputLineCount > MAX_OUTPUT_LINES) {
+                this.outputSuppressed = true;
+                continue;
+            }
+            this.channel.writeRaw(`${GUTTER}${line}\n`);
         }
     }
     /** Dimmed reasoning stream (already colored by the agent). */
     reasoning(chunk) {
         this.spinner.stop();
-        this.out.write(pc.dim(chunk));
+        if (this.thoughtStarted && !this.thoughtHeaderPrinted) {
+            this.channel.writeRaw(`\n${pc.dim("→")} Thought: `);
+            this.thoughtHeaderPrinted = true;
+        }
+        this.channel.writeRaw(pc.dim(chunk));
     }
-    /** Model is loading / generating — show the thinking spinner. */
+    /** Model is loading / generating — record start time. */
     thinkingStart() {
+        this.thoughtStarted = true;
+        this.thoughtStartMs = Date.now();
+        this.thoughtHeaderPrinted = false;
         this.spinner.start(t("ui.thinking"));
     }
-    /** LLM call finished; clear the thinking spinner. */
+    /** LLM call finished; print duration and close the thought block. */
     thinkingEnd() {
         this.spinner.stop();
+        if (this.thoughtStarted && this.thoughtHeaderPrinted) {
+            const duration = Date.now() - this.thoughtStartMs;
+            this.channel.writeRaw(pc.dim(` ${duration}ms\n`));
+        }
+        this.thoughtStarted = false;
+        this.thoughtHeaderPrinted = false;
     }
     toolStart(tool, args, stepContext, icon) {
-        this.endCard();
         this.spinner.stop();
+        this.fmt.flushPartialNow();
+        this.endCard();
+        this.outputLineCount = 0;
+        this.outputSuppressed = false;
         const displayArgs = PATH_TOOLS.has(tool) && typeof args.path === "string"
             ? { ...args, path: toDisplayPath(this.baseDir, args.path) }
             : args;
         const summary = summarizeArgs(displayArgs);
-        const step = stepContext ? ` ${pc.cyan(`← ${stepContext}`)}` : "";
         const marker = icon || toolMarker(tool);
-        if (!this.rich) {
-            this.out.write(`\n${pc.dim(marker)} ${friendlyTool(tool)}${summary ? ` ${pc.dim(summary)}` : ""}${step}\n`);
-            return;
+        const label = friendlyTool(tool);
+        this.card = { tool, args, start: Date.now() };
+        if (stepContext) {
+            this.channel.writeRaw(`\n${pc.dim("↓")} ${pc.cyan(stepContext)}\n`);
         }
-        this.card = { tool, args, body: [], start: Date.now() };
-        if (this.toolStyle === "inline") {
-            this.out.write(`\n${pc.dim(marker)} ${friendlyTool(tool)}${summary ? ` ${pc.dim(summary)}` : ""}${step}\n`);
-            if (BUSY_TOOLS.has(tool)) {
-                this.spinner.start(t("ui.tool_running", { tool: friendlyTool(tool) }));
-            }
-            return;
+        this.channel.writeRaw(`${pc.dim(marker)} ${label}${summary ? ` ${pc.dim(summary)}` : ""}\n`);
+        // Busy indicator while the tool actually runs — read/write/edit/bash can
+        // take seconds; without this the chat looks frozen until the footer.
+        if (!SPINNERLESS_TOOLS.has(tool)) {
+            this.spinner.start(`${label}${summary ? ` ${summary}` : ""}`);
         }
-        this.spinner.start(`${pc.dim(marker)} ${friendlyTool(tool)}${summary ? ` ${pc.dim(summary)}` : ""}${step}`);
     }
     /** Live plan checklist — prints the plan block as-is (already colored). */
     planBlock(lines) {
-        this.endCard();
         this.spinner.stop();
+        this.fmt.flushPartialNow();
+        this.endCard();
         for (const line of lines) {
-            this.out.write(`${line}\n`);
+            this.channel.writeRaw(`${line}\n`);
         }
     }
-    toolEnd(_tool, duration, error, ctxDelta, costUsd, provider, model) {
+    toolEnd(_tool, duration, error, ctxDelta, costUsd) {
         this.spinner.stop();
-        const prov = provider && model ? `${pc.dim(`${provider}·${model}`)}` : undefined;
-        if (!this.rich) {
-            const parts = [];
-            if (ctxDelta !== undefined && ctxDelta !== 0) {
-                const deltaStr = ctxDelta > 0 ? pc.green(`+${ctxDelta}`) : pc.yellow(`${ctxDelta} ↓`);
-                parts.push(`${pc.dim("ctx")} ${deltaStr}`);
-            }
-            if (costUsd !== undefined && costUsd > 0) {
-                parts.push(`${pc.dim("cost")} ${pc.yellow(formatUsd(costUsd))}`);
-            }
-            if (prov)
-                parts.push(prov);
-            if (parts.length > 0)
-                this.out.write(`${parts.join("  ")}\n`);
-            return;
-        }
+        this.fmt.flushPartialNow();
         if (!this.card)
             return;
-        const { tool, args, body } = this.card;
         const marker = error ? pc.red("✗") : pc.green("✓");
-        let footer = `${marker} ${pc.dim(`${duration}ms`)}`;
+        let footer = `${GUTTER}${marker} ${pc.dim(`${duration}ms`)}`;
         if (ctxDelta !== undefined && ctxDelta !== 0) {
             const deltaStr = ctxDelta > 0 ? pc.green(`+${ctxDelta}`) : pc.yellow(`${ctxDelta} ↓`);
             footer += `  ${pc.dim("ctx")} ${deltaStr}`;
@@ -208,47 +224,35 @@ export class Renderer {
         if (costUsd !== undefined && costUsd > 0) {
             footer += `  ${pc.dim("cost")} ${pc.yellow(formatUsd(costUsd))}`;
         }
-        if (prov) {
-            footer += `  ${pc.dim("via")} ${prov}`;
-        }
-        if (this.toolStyle === "inline") {
-            this.out.write(`${GUTTER}${footer}\n`);
-            this.out.write(`${divider(this.width)}\n`);
-            this.card = null;
-            return;
-        }
-        const lines = [];
-        const summary = summarizeArgs(args);
-        if (summary)
-            lines.push(pc.dim(summary));
-        for (const chunk of body) {
-            for (const line of chunk.split("\n")) {
-                if (line.trim() !== "")
-                    lines.push(line);
-            }
-        }
-        lines.push(footer);
-        const title = `${marker} ${friendlyTool(tool)}`;
-        for (const line of box(lines, { title, width: this.width })) {
-            this.out.write(`${line}\n`);
+        this.channel.writeRaw(`${footer}\n`);
+        if (this.outputSuppressed) {
+            this.channel.writeRaw(`${GUTTER}${pc.dim(`... (${this.outputLineCount - MAX_OUTPUT_LINES} more lines)`)}\n`);
         }
         this.card = null;
     }
     /** Raw pre-formatted text (diff blocks, warnings). */
     raw(text) {
-        this.endCard();
         this.spinner.stop();
-        this.out.write(text);
+        this.fmt.flushPartialNow();
+        this.endCard();
+        this.channel.writeRaw(text);
     }
     error(text) {
-        this.endCard();
         this.spinner.stop();
-        this.err.write(`${pc.red(text)}\n`);
+        this.fmt.flushPartialNow();
+        this.endCard();
+        this.channel.writeRaw(`${pc.red(text)}\n`, "stderr");
     }
     flush() {
         this.endCard();
         this.spinner.stop();
+        this.fmt.flushPartialNow();
         this.fmt.flush();
+        this.textStarted = false;
+    }
+    /** Footer with model, provider, and total duration. */
+    footer(model, provider, durationMs) {
+        this.channel.writeRaw(`\n${pc.dim("▣")} ${model} · ${provider} · ${pc.dim(`${durationMs}ms`)}\n`);
     }
     endCard() {
         if (!this.card)

package/dist/ui/spinner.js

@@ -16,12 +16,14 @@ export class Spinner {
     frame = 0;
     message = "";
     enabled;
+    channel;
     stream;
     intervalMs;
     width;
     constructor(opts = {}) {
-        this.stream = opts.stream ?? process.stderr;
-        this.enabled = opts.enabled ?? isSpinnerSupported(this.stream);
+        this.channel = opts.channel;
+        this.stream = process.stderr;
+        this.enabled = opts.enabled ?? isSpinnerSupported();
         this.intervalMs = opts.intervalMs ?? 80;
         this.width = opts.width ?? getTerminalWidth();
     }
@@ -46,7 +48,11 @@ export class Spinner {
         if (this.timer) {
             clearInterval(this.timer);
             this.timer = null;
-            this.stream.write("\r\x1b[K");
+            const clear = "\r\x1b[K";
+            if (this.channel)
+                this.channel.writeOverlay(clear);
+            else
+                this.stream.write(clear);
         }
     }
     truncate(text) {
@@ -65,6 +71,10 @@ export class Spinner {
             return;
         const frame = FRAMES[this.frame % FRAMES.length];
         this.frame++;
-        this.stream.write("\r" + pc.cyan(frame) + " " + this.message + "\x1b[K");
+        const text = "\r" + pc.cyan(frame) + " " + this.message + "\x1b[K";
+        if (this.channel)
+            this.channel.writeOverlay(text);
+        else
+            this.stream.write(text);
     }
 }

package/dist/utils/error.js

@@ -0,0 +1,4 @@
+/** Extract a human-readable message from an unknown thrown value. */
+export function errMsg(e) {
+    return e instanceof Error ? e.message : String(e);
+}

package/dist/utils/index.js

@@ -0,0 +1,4 @@
+export { sleep } from "./sleep";
+export { truncate } from "./truncate";
+export { backoffDelay } from "./retry";
+export { errMsg } from "./error";

package/dist/utils/retry.js

@@ -0,0 +1,17 @@
+/**
+ * Экспоненциальная задержка повтора с опциональным джиттером.
+ *
+ * Единая реализация вместо четырёх расходящихся копий:
+ * - openai-compat (стрим и fetchWithRetry): `min(base*2^attempt, max)` + jitter;
+ * - moe-executor: `min(1000*2^(attempt-1), 8000)` без jitter;
+ * - audit-notifier: `2^retries * 1000` без потолка.
+ *
+ * `maxDelay === undefined` — без потолка (копия audit-notifier).
+ * `jitterFactor === 0` — без джиттера (копии moe/audit-notifier).
+ */
+export function backoffDelay(attempt, baseDelay, maxDelay, jitterFactor = 0) {
+    const base = maxDelay !== undefined
+        ? Math.min(baseDelay * Math.pow(2, attempt), maxDelay)
+        : baseDelay * Math.pow(2, attempt);
+    return base + Math.random() * baseDelay * jitterFactor;
+}

package/dist/utils/sleep.js

@@ -0,0 +1,23 @@
+/**
+ * Сон с поддержкой отмены. При abort сигнала отклоняет DOMException
+ * "AbortError" — тот же контракт, что у fetch/AbortController, чтобы
+ * вызывающий код обрабатывал прерывание единообразно.
+ */
+export function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(new DOMException("Aborted", "AbortError"));
+            return;
+        }
+        let timer;
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(new DOMException("Aborted", "AbortError"));
+        };
+        timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}

package/dist/utils/truncate.js

@@ -0,0 +1,9 @@
+/**
+ * Обрезка строки с многоточием. Раньше жила приватной в context/manager.ts
+ * и переписывалась инлайном в openai-compat и mcp/client.
+ */
+export function truncate(s, max) {
+    if (s.length <= max)
+        return s;
+    return s.slice(0, max - 3) + "...";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "micro-models-agent",
-  "version": "0.63.3",
+  "version": "1.1.0",
   "description": "Micro Models Agent (MMA) — LLM agent harness for small models (Qwen3.5-9B, 32K-64K context)",
   "type": "module",
   "bin": {