micro-models-agent 0.51.1 → 0.52.0

package/dist/tools/web-search.js

@@ -2,8 +2,53 @@ import { t } from "../i18n/index";
 import { isUrlAllowed, sanitizeUrl } from "../modules/security/network-validator";
 import { logNetworkRequest, logSecurityBlock } from "../modules/security/audit-log";
 import { getSessionSecurityConfig } from "../modules/security/session-isolation";
+/**
+ * Shared web search (DuckDuckGo HTML) used by BOTH the web_search tool and
+ * the automatic error search (execution module). `networkConfig` is the
+ * resolved security network config (may be undefined when security is off);
+ * `requestTimeoutMs` overrides the timeout when the caller has its own
+ * setting (the error search uses errorWebSearch.requestTimeoutMs).
+ */
+export async function performWebSearch(query, numResults, networkConfig, requestTimeoutMs) {
+    const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+    const validation = isUrlAllowed(url, networkConfig);
+    if (!validation.allowed) {
+        return {
+            success: false,
+            blocked: true,
+            results: [],
+            error: validation.reason || "URL blocked by security policy",
+        };
+    }
+    try {
+        const response = await fetch(url, {
+            signal: AbortSignal.timeout(requestTimeoutMs ?? networkConfig?.requestTimeout ?? 10000),
+        });
+        const html = await response.text();
+        const results = [];
+        const snippetRegex = /<a[^>]+class="result__a"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/gi;
+        let match;
+        while ((match = snippetRegex.exec(html)) !== null && results.length < numResults) {
+            results.push({
+                url: match[1].trim(),
+                title: match[2].replace(/<[^>]+>/g, "").trim(),
+                snippet: match[3].replace(/<[^>]+>/g, "").trim(),
+            });
+        }
+        return { success: true, results };
+    }
+    catch (err) {
+        return { success: false, results: [], error: err.message };
+    }
+}
+function formatResults(results) {
+    return results
+        .map((r, i) => `${i + 1}. ${r.title}\n   URL: ${r.url}\n   ${r.snippet}`)
+        .join("\n");
+}
 export const webSearchTool = {
     name: "web_search",
+    icon: "🌍",
     description: "Search the web for information. Returns search results with titles and snippets. Use this for search queries instead of opening search engines (Google/Yandex/Bing) in the browser — they block headless browsers.",
     tags: ["research"],
     parameters: {
@@ -18,61 +63,43 @@ export const webSearchTool = {
         required: ["query"],
     },
     handler: async (ctx, args) => {
+        if (ctx.config?.webSearch?.enabled === false) {
+            return { success: false, output: t("tool.web_search_disabled") };
+        }
         const query = String(args.query || "");
         const numResults = Number(args.numResults) || 5;
-        // Build search URL
-        const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
-        // Get session-specific security config
         const securityConfig = ctx.sessionContext
             ? getSessionSecurityConfig(ctx.config, ctx.sessionContext).network
             : ctx.config.security?.network;
-        const validation = isUrlAllowed(url, securityConfig);
-        if (!validation.allowed) {
-            logSecurityBlock(ctx.sessionId, "network_request", validation.reason || "URL blocked by security policy", sanitizeUrl(url));
+        const outcome = await performWebSearch(query, numResults, securityConfig);
+        const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+        if (outcome.blocked) {
+            logSecurityBlock(ctx.sessionId, "network_request", outcome.error || "URL blocked by security policy", sanitizeUrl(url));
             return {
                 success: false,
-                output: `[SECURITY BLOCKED] Search URL is not allowed: ${validation.reason}`,
+                output: t("error.search_failed", { message: String(outcome.error) }),
             };
         }
-        try {
-            const response = await fetch(url, {
-                signal: AbortSignal.timeout(securityConfig?.requestTimeout || 10000),
-            });
-            const html = await response.text();
-            const results = [];
-            const snippetRegex = /<a[^>]+class="result__a"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/gi;
-            let match;
-            let count = 0;
-            while ((match = snippetRegex.exec(html)) !== null && count < numResults) {
-                const href = match[1].trim();
-                const title = match[2].replace(/<[^>]+>/g, "").trim();
-                const snippet = match[3].replace(/<[^>]+>/g, "").trim();
-                results.push(`${count + 1}. ${title}\n   URL: ${href}\n   ${snippet}`);
-                count++;
-            }
-            // Log successful network request
-            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), true, `Results: ${results.length}`);
-            if (results.length === 0) {
-                return { success: true, output: t("tool.no_results", { query }) };
-            }
-            return {
-                success: true,
-                output: t("tool.search_results", {
-                    query,
-                    results: results.join("\n"),
-                }),
-                display: t("tool.web_search_result", {
-                    query,
-                    count: String(results.length),
-                }),
-            };
-        }
-        catch (err) {
-            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Error: ${err.message}`);
+        logNetworkRequest(ctx.sessionId, sanitizeUrl(url), outcome.success, `Results: ${outcome.results.length}`);
+        if (!outcome.success) {
             return {
                 success: false,
-                output: t("error.search_failed", { message: err.message }),
+                output: t("error.search_failed", { message: String(outcome.error) }),
             };
         }
+        if (outcome.results.length === 0) {
+            return { success: true, output: t("tool.no_results", { query }) };
+        }
+        return {
+            success: true,
+            output: t("tool.search_results", {
+                query,
+                results: formatResults(outcome.results),
+            }),
+            display: t("tool.web_search_result", {
+                query,
+                count: String(outcome.results.length),
+            }),
+        };
     },
 };

package/dist/tools/write-file.js

@@ -9,6 +9,7 @@ import { generateDiff, generateNewFileDiff } from "../ui/diff";
 import { safeResolvePath } from "./path-utils";
 export const writeFileTool = {
     name: "write_file",
+    icon: "📝",
     description: "Create or overwrite a file with given content. Creates intermediate directories if needed.",
     tags: ["file", "code"],
     parameters: {

package/dist/ui/line-editor.js

@@ -6,6 +6,7 @@ export class LineEditor {
     output;
     /** Host hook: return true to swallow the key before the editor handles it. */
     onKeyInput;
+    onInterrupt;
     promptStr;
     completer;
     history;
@@ -29,15 +30,28 @@ export class LineEditor {
     rawMode = false;
     listeners = {};
     /** Visual row (within the drawn frame) where the cursor was placed by the
-     *  last render — used to move back to the frame's first row before
-     *  redrawing, so a redraw starting on a middle/bottom row never leaves
-     *  stale lines above (duplicated input text on newline). */
+     *  last render — fallback for moving back to the frame's first row before
+     *  redrawing when no absolute anchor is known yet. Relative moves break
+     *  once the terminal scrolls (the frame shifts up on screen while the
+     *  relative count does not), which duplicated multi-line input. */
     prevCursorRow = 0;
+    /** Absolute 1-based screen row of the frame's first visual row, learned
+     *  from a single DSR cursor-position report (`ESC[6n`) sent once per
+     *  prompt presentation. After the initial query the anchor is updated
+     *  deterministically via scroll math — no further queries are sent,
+     *  avoiding ConPTY desync. Falls back to relative moves when the reply
+     *  never arrives (timeout / broken terminal). */
+    frameTopAbs = null;
+    /** True while waiting for a DSR reply (exactly one outstanding query). */
+    dsrPending = false;
+    /** Buffer for partial DSR escape sequences split across data chunks. */
+    dsrTail = "";
     constructor(opts) {
         this.input = opts.input;
         this.output = opts.output;
         this.promptStr = opts.prompt ?? "";
         this.completer = opts.completer;
+        this.onInterrupt = opts.onInterrupt;
         this.history = opts.history ?? [];
         this.historySize = opts.historySize ?? 50;
         if (this.history.length > this.historySize) {
@@ -48,6 +62,10 @@ export class LineEditor {
             if (this.rawMode)
                 this.input.setRawMode(true);
             this.enableTerminalProtocols();
+            // Raw data listener for DSR cursor-position replies. Runs alongside
+            // readline's keypress emitter (both receive every chunk); replies may
+            // arrive merged with regular keystrokes, hence the global regex.
+            this.input.on("data", (buf) => this.consumeDsrReplies(buf.toString("utf-8")));
             readline.emitKeypressEvents(this.input);
             this.input.on("keypress", (str, key) => this.onKey(str, key));
         }
@@ -91,7 +109,7 @@ export class LineEditor {
         this.col = 0;
         this.historyIndex = -1;
         this.stash = null;
-        this.prevCursorRow = 0;
+        this.invalidateAnchor();
         if (this.input.isTTY)
             this.render();
     }
@@ -101,7 +119,7 @@ export class LineEditor {
         this.lines = [""];
         this.row = 0;
         this.col = 0;
-        this.prevCursorRow = 0;
+        this.invalidateAnchor();
         if (this.input.isTTY)
             this.render();
     }
@@ -213,6 +231,12 @@ export class LineEditor {
                     this.lastWasCR = false;
                     return;
                 }
+                // In question mode, LF should also submit (script/pipes send
+                // \n without preceding \r, unlike real terminals).
+                if (this.questionCb) {
+                    this.submit();
+                    return;
+                }
                 this.insertNewline();
                 return;
             case "backspace":
@@ -319,10 +343,10 @@ export class LineEditor {
             const answer = this.lines.join("\n").trim();
             this.commitFrame();
             this.output.write("\r\n");
+            this.invalidateAnchor();
             this.lines = [""];
             this.row = 0;
             this.col = 0;
-            this.prevCursorRow = 0;
             cb(answer);
             return;
         }
@@ -337,19 +361,25 @@ export class LineEditor {
         this.stash = null;
         this.commitFrame();
         this.output.write("\r\n");
+        this.invalidateAnchor();
         this.lines = [""];
         this.row = 0;
         this.col = 0;
-        this.prevCursorRow = 0;
         this.emitLine(text);
     }
     /** Move the cursor to the end of the buffer's last visual row so the
-     *  submitted text stays on screen (commit), without erasing the frame. */
+     *  submitted text stays on screen (commit), without erasing the frame.
+     *  Uses the absolute anchor when known — relative moves land short once
+     *  a tall frame has scrolled the terminal. */
     commitFrame() {
-        const layout = this.layout();
+        const layout = this.visibleLayout();
+        const lastLen = charLen(stripAnsi(layout[layout.length - 1].text));
+        if (this.frameTopAbs !== null) {
+            this.output.write(`\x1b[${this.frameTopAbs + layout.length - 1};${lastLen + 1}H`);
+            return;
+        }
         const idx = layoutIndexFor(layout, this.row, this.col);
         const rowsDown = layout.length - 1 - idx;
-        const lastLen = charLen(stripAnsi(layout[layout.length - 1].text));
         const out = [];
         if (rowsDown > 0)
             out.push(`\x1b[${rowsDown}B`);
@@ -362,9 +392,18 @@ export class LineEditor {
         this.lines = [""];
         this.row = 0;
         this.col = 0;
-        this.prevCursorRow = 0;
+        this.invalidateAnchor();
         this.render();
-        process.emit("SIGINT");
+        if (this.onInterrupt) {
+            this.onInterrupt();
+            return;
+        }
+        // Default: emit only when someone listens. With zero handlers
+        // process.emit("SIGINT") takes the DEFAULT action (process termination);
+        // the REPL always installs a listener, so production is unaffected.
+        if (process.listenerCount("SIGINT") > 0) {
+            process.emit("SIGINT");
+        }
     }
     ctrlD() {
         if (this.lines.length === 1 && this.lines[0] === "") {
@@ -641,7 +680,7 @@ export class LineEditor {
     }
     clearScreen() {
         this.output.write("\x1b[2J\x1b[H");
-        this.prevCursorRow = 0;
+        this.invalidateAnchor();
         this.render();
     }
     // ---- rendering ----
@@ -649,26 +688,83 @@ export class LineEditor {
         return this.output.columns || 80;
     }
     layout() {
-        return buildLayout(this.lines, this.columns());
+        const promptWidth = stringWidth(stripAnsi(this.promptStr));
+        return buildLayout(this.lines, this.columns(), Math.max(1, this.columns() - promptWidth));
+    }
+    /** 1-based terminal height, or null when unknown (tests / non-TTY). */
+    screenRows() {
+        const r = this.output.rows;
+        return typeof r === "number" && r > 3 ? r : null;
+    }
+    /** Cap the rendered frame to the visible screen. A frame taller than the
+     *  terminal cannot be redrawn in place at all (its top scrolls off), so
+     *  only the tail is drawn; the absolute anchor keeps the next render
+     *  consistent regardless. */
+    visibleLayout() {
+        const layout = this.layout();
+        const H = this.screenRows();
+        const maxRows = H ? H - 2 : 0;
+        if (maxRows > 0 && layout.length > maxRows) {
+            return layout.slice(layout.length - maxRows);
+        }
+        return layout;
+    }
+    /** Forget the learned absolute frame position — the cursor has jumped to
+     *  an unknown location (external output, clear screen, fresh prompt).
+     *  The next render will re-query via DSR. */
+    invalidateAnchor() {
+        this.frameTopAbs = null;
+        this.dsrPending = false;
+        this.dsrTail = "";
+        this.prevCursorRow = 0;
+    }
+    /** Parse `ESC[row;colR` cursor-position replies. Buffers partial escape
+     *  sequences across chunks. Accepts at most one reply (the outstanding
+     *  query); extras are silently dropped. Validates the reported row against
+     *  `screenRows()` to reject implausible ConPTY values. */
+    consumeDsrReplies(chunk) {
+        this.dsrTail = (this.dsrTail + chunk).slice(-80);
+        const m = /\x1b\[(\d+);(\d+)R/.exec(this.dsrTail);
+        if (!m)
+            return;
+        this.dsrTail = "";
+        if (!this.dsrPending)
+            return;
+        this.dsrPending = false;
+        const row = Number(m[1]);
+        const idx = Number(m[2]);
+        // idx is not the layout index — it's the column from the reply; ignore it.
+        // We compute frameTop from the reply row minus the cursor's visual row
+        // at query time.  The visual row was stored in `prevCursorRow` when the
+        // query was sent (right after render).
+        const top = row - this.prevCursorRow;
+        if (top >= 1)
+            this.frameTopAbs = top;
     }
     render() {
         if (!this.input.isTTY || this.isDone)
             return;
-        const layout = this.layout();
+        const layout = this.visibleLayout();
         const promptWidth = stringWidth(stripAnsi(this.promptStr));
         const idx = layoutIndexFor(layout, this.row, this.col);
         const vcol = visualColAt(layout, idx, this.col);
         const rowsAfter = layout.length - idx - 1;
         const ccol = (idx === 0 ? promptWidth : 0) + vcol;
         const out = [];
-        // Move back up to the frame's first row before redrawing. Without this,
-        // a redraw that starts on a middle/bottom row (e.g. typing on line 2 of
-        // a multi-line buffer) writes the whole frame one row too low and leaves
-        // the previous frame's top line stale on screen — the user sees every
-        // line duplicated.
-        if (this.prevCursorRow > 0)
+        // Return to the frame's first row before redrawing.  Absolute
+        // positioning (learned via a single DSR query per prompt) is
+        // scroll-proof; relative up-moves are the fallback until the
+        // initial reply arrives.
+        if (this.frameTopAbs !== null) {
+            out.push(`\x1b[${this.frameTopAbs};1H`);
+        }
+        else if (this.prevCursorRow > 0) {
             out.push(`\x1b[${this.prevCursorRow}A`);
-        out.push("\r");
+            out.push("\r");
+        }
+        else {
+            out.push("\r");
+        }
         for (let i = 0; i < layout.length; i++) {
             out.push("\x1b[2K");
             if (i === 0)
@@ -683,8 +779,31 @@ export class LineEditor {
         out.push("\r");
         if (ccol > 0)
             out.push(`\x1b[${ccol}C`);
-        this.prevCursorRow = idx;
         this.output.write(out.join(""));
+        // Deterministic scroll math: update the anchor for the NEXT render.
+        // After writing L rows starting from frameTopAbs, if the frame extends
+        // past the screen bottom the terminal scrolls; the new frame top is
+        // computed locally — no further DSR queries needed.
+        if (this.frameTopAbs !== null) {
+            const H = this.screenRows();
+            if (H) {
+                const T = this.frameTopAbs;
+                const L = layout.length;
+                if (T + L - 1 > H)
+                    this.frameTopAbs = H - L + 1;
+                // else: no scroll, anchor unchanged
+            }
+        }
+        else if (!this.dsrPending) {
+            // First render after prompt — send exactly ONE DSR query.
+            // Disabled for now: ConPTY may buffer stdout while processing
+            // the DSR reply, hiding agent responses.  Will revisit once
+            // scroll-proof rendering is solved via deterministic tracking.
+            //
+            // this.dsrPending = true;
+            // this.output.write("\x1b[6n");
+        }
+        this.prevCursorRow = idx;
     }
     enableTerminalProtocols() {
         this.output.write("\x1b[?2004h");

package/dist/ui/line-math.js

@@ -6,8 +6,11 @@ export function stripAnsi(s) {
 export function charLen(s) {
     return Array.from(s).length;
 }
-export function wrapLine(line, width) {
+export function wrapLine(line, width, firstRowWidth) {
     const w = width > 0 ? width : 80;
+    // Only the FIRST visual row shares its screen line with something else
+    // (e.g. the prompt); every continuation row uses the full width.
+    let limit = firstRowWidth !== undefined && firstRowWidth > 0 ? firstRowWidth : w;
     const chars = Array.from(line);
     const rows = [];
     let start = 0;
@@ -21,10 +24,11 @@ export function wrapLine(line, width) {
             continue;
         }
         const cw = stringWidth(ch);
-        if (cells + cw > w && cells > 0) {
+        if (cells + cw > limit && cells > 0) {
             rows.push({ text: chars.slice(start, i).join(""), charStart: start });
             start = i;
             cells = cw;
+            limit = w;
         }
         else {
             cells += cw;
@@ -33,10 +37,10 @@ export function wrapLine(line, width) {
     rows.push({ text: chars.slice(start).join(""), charStart: start });
     return rows;
 }
-export function buildLayout(lines, width) {
+export function buildLayout(lines, width, firstRowWidth) {
     const rows = [];
     for (let b = 0; b < lines.length; b++) {
-        for (const r of wrapLine(lines[b], width)) {
+        for (const r of wrapLine(lines[b], width, b === 0 ? firstRowWidth : undefined)) {
             rows.push({ bufRow: b, charStart: r.charStart, text: r.text });
         }
     }

package/dist/ui/renderer.js

@@ -4,7 +4,34 @@ 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 { isAbsolute, relative, sep } from "path";
+function formatUsd(cost) {
+    return formatCost(cost);
+}
+/** Tools whose `path` argument is shown in the header. */
+const PATH_TOOLS = new Set([
+    "read_file",
+    "write_file",
+    "edit_file",
+    "delete_file",
+    "create_dir",
+    "move_file",
+    "list_dir",
+    "file_info",
+]);
+function toDisplayPath(baseDir, p) {
+    if (!baseDir || !isAbsolute(p))
+        return p;
+    const rel = relative(baseDir, p);
+    // Outside baseDir (../ prefix) or another drive (absolute result) → keep as-is.
+    if (!rel || rel.startsWith("..") || isAbsolute(rel))
+        return 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"]);
 /** opencode-like leading marker per tool category. */
 export function toolMarker(tool) {
     switch (tool) {
@@ -62,6 +89,7 @@ export class Renderer {
     err;
     width;
     toolStyle;
+    baseDir;
     card = null;
     constructor(opts = {}) {
         this.rich = opts.rich ?? isRichTerminal();
@@ -69,6 +97,7 @@ export class Renderer {
         this.err = opts.err ?? process.stderr;
         this.width = opts.width ?? getTerminalWidth();
         this.toolStyle = opts.toolStyle ?? "inline";
+        this.baseDir = opts.baseDir;
         this.spinner = new Spinner({
             enabled: this.rich && (opts.spinner ?? true),
             stream: this.err,
@@ -118,22 +147,28 @@ export class Renderer {
     thinkingEnd() {
         this.spinner.stop();
     }
-    toolStart(tool, args, stepContext) {
+    toolStart(tool, args, stepContext, icon) {
         this.endCard();
         this.spinner.stop();
-        const summary = summarizeArgs(args);
+        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("⚙")} ${friendlyTool(tool)}${summary ? ` ${pc.dim(summary)}` : ""}${step}\n`);
+            this.out.write(`\n${pc.dim(marker)} ${friendlyTool(tool)}${summary ? ` ${pc.dim(summary)}` : ""}${step}\n`);
             return;
         }
         this.card = { tool, args, body: [], start: Date.now() };
         if (this.toolStyle === "inline") {
-            const marker = toolMarker(tool);
             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.spinner.start(`${pc.dim("⚙")} ${friendlyTool(tool)}${summary ? ` ${pc.dim(summary)}` : ""}${step}`);
+        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) {
@@ -143,13 +178,22 @@ export class Renderer {
             this.out.write(`${line}\n`);
         }
     }
-    toolEnd(_tool, duration, error, ctxDelta) {
+    toolEnd(_tool, duration, error, ctxDelta, costUsd, provider, model) {
         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} ↓`);
-                this.out.write(`${pc.dim("ctx")} ${deltaStr}\n`);
+                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;
         }
         if (!this.card)
@@ -161,6 +205,12 @@ export class Renderer {
             const deltaStr = ctxDelta > 0 ? pc.green(`+${ctxDelta}`) : pc.yellow(`${ctxDelta} ↓`);
             footer += `  ${pc.dim("ctx")} ${deltaStr}`;
         }
+        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`);