micro-models-agent 0.41.0 → 0.41.2

package/dist/modules/updater/module.js

@@ -0,0 +1,116 @@
+import { Updater } from "./checker";
+import { t } from "../../i18n/index";
+import { pc } from "../../ui/colors";
+/**
+ * Self-update module. Fires an ASYNC (non-blocking) check at startup so the
+ * agent never waits on the network. When `autoInstall` is enabled, a newer
+ * version is installed globally via `npm install -g` in the background and
+ * the user is notified; the running process keeps working on the old version
+ * until the next launch.
+ */
+export class UpdaterModule {
+    name = "updater";
+    updater;
+    config;
+    logger;
+    started = false;
+    timer = null;
+    /** Promise of the current run-loop pass (resolves when it settles). */
+    idlePromise = null;
+    /** Test hook: disable real npm installs. */
+    installEnabled = true;
+    constructor(config, currentVersion, packageName, logger, installRunner) {
+        this.config = config;
+        this.updater = new Updater(currentVersion, packageName, installRunner);
+        this.logger = logger ?? {
+            info: () => { },
+            warn: (m) => console.warn(pc.yellow(m)),
+            error: (m) => console.error(pc.red(m)),
+        };
+    }
+    /** Test hook: prevent the module from actually running npm install. */
+    setInstallEnabled(enabled) {
+        this.installEnabled = enabled;
+    }
+    getUpdater() {
+        return this.updater;
+    }
+    isStarted() {
+        return this.started;
+    }
+    /**
+     * Start the background check. Returns immediately (fire-and-forget) so the
+     * caller never blocks on the registry. Use `intervalMs > 0` for a permanent
+     * re-check loop (the "auto-update daemon" behavior).
+     */
+    start() {
+        if (this.started || !this.config.enabled)
+            return;
+        this.started = true;
+        this.idlePromise = this.runLoop();
+    }
+    stop() {
+        this.started = false;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+    /**
+     * Wait for the current check/install cycle to settle, bounded by timeoutMs.
+     * Used by one-shot CLI runs so a background `npm install -g` isn't killed by
+     * process.exit() before it completes. No-op when the module never started.
+     */
+    async waitForIdle(timeoutMs = 130000) {
+        const idle = this.idlePromise;
+        if (!idle)
+            return;
+        await Promise.race([idle, new Promise((r) => setTimeout(r, timeoutMs))]);
+    }
+    async runLoop() {
+        while (this.started) {
+            await this.checkOnce();
+            if (!this.started)
+                return;
+            if (this.config.intervalMs > 0) {
+                await new Promise((r) => (this.timer = setTimeout(r, this.config.intervalMs)));
+            }
+            else {
+                this.started = false;
+            }
+        }
+    }
+    /** Perform a single check; if an update is available, optionally install it. */
+    async runOnce() {
+        const result = await this.updater.check();
+        if (result.error) {
+            this.logger.info(t("updater.check_error", { error: result.error }));
+            return;
+        }
+        if (!result.updateAvailable || !result.latest)
+            return;
+        if (this.config.autoInstall && this.installEnabled) {
+            this.logger.info(t("updater.installing", {
+                current: result.current,
+                latest: result.latest,
+            }));
+            const install = await this.updater.install(result.latest);
+            if (install.success) {
+                this.logger.info(t("updater.installed", { current: result.current, latest: result.latest }));
+            }
+            else {
+                this.logger.warn(t("updater.install_failed", {
+                    current: result.current,
+                    latest: result.latest,
+                    error: install.error ?? "",
+                }));
+            }
+        }
+        else {
+            this.logger.info(t("updater.available", { current: result.current, latest: result.latest }));
+        }
+    }
+    async checkOnce() {
+        await this.runOnce();
+    }
+}

package/dist/modules/user-profile/compressor.js

@@ -8,9 +8,9 @@ export class ProfileCompressor {
         if (Object.keys(info.preferences).length > 0) {
             const prefs = Object.entries(info.preferences)
                 .map(([k, v]) => `${k}=${v}`)
-                .join(',');
+                .join(",");
             parts.push(`Prefs: ${prefs}`);
         }
-        return parts.join(', ');
+        return parts.join(", ");
     }
 }

package/dist/modules/user-profile/index.js

@@ -1 +1 @@
-export { UserProfile } from './profile';
+export { UserProfile } from "./profile";

package/dist/modules/user-profile/profile.js

@@ -1,8 +1,8 @@
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { homedir, hostname, platform, type } from 'os';
-import { env } from 'process';
-import { ProfileCompressor } from './compressor';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir, hostname, platform, type } from "os";
+import { env } from "process";
+import { ProfileCompressor } from "./compressor";
 export class UserProfile {
     profileDir;
     info = null;
@@ -15,7 +15,7 @@ export class UserProfile {
             platform: platform(),
             os: `${type()} ${hostname()}`,
             hostname: hostname(),
-            shell: env.SHELL || env.ComSpec || 'unknown',
+            shell: env.SHELL || env.ComSpec || "unknown",
             home: homedir(),
             nodeVersion: process.version,
             preferences: { ...this.preferences },
@@ -26,14 +26,14 @@ export class UserProfile {
         if (!existsSync(this.profileDir)) {
             mkdirSync(this.profileDir, { recursive: true });
         }
-        writeFileSync(join(this.profileDir, 'profile.json'), JSON.stringify({ ...this.info, preferences: this.preferences }, null, 2), 'utf-8');
+        writeFileSync(join(this.profileDir, "profile.json"), JSON.stringify({ ...this.info, preferences: this.preferences }, null, 2), "utf-8");
     }
     load() {
-        const path = join(this.profileDir, 'profile.json');
+        const path = join(this.profileDir, "profile.json");
         if (!existsSync(path))
             return null;
         try {
-            const data = JSON.parse(readFileSync(path, 'utf-8'));
+            const data = JSON.parse(readFileSync(path, "utf-8"));
             this.info = {
                 platform: data.platform,
                 os: data.os,

package/dist/tools/attach-image.js

@@ -1,7 +1,7 @@
 import { existsSync } from "fs";
 import { resolve } from "path";
 import { t } from "../i18n/index";
-import { loadFileAsDataUrl, loadUrlAsDataUrl, readClipboardImage, bufferToDataUrl } from "../llm/image-utils";
+import { loadFileAsDataUrl, loadUrlAsDataUrl, readClipboardImage, bufferToDataUrl, } from "../llm/image-utils";
 import { logSecurityBlock } from "../modules/security/audit-log";
 export const attachImageTool = {
     name: "attach_image",

package/dist/tools/bash.js

@@ -1,8 +1,8 @@
-import { isCommandAllowed, sanitizeCommandForLog, } from "../modules/security/command-validator";
-import { logBashCommand, logSecurityBlock, } from "../modules/security/audit-log";
+import { isCommandAllowed, sanitizeCommandForLog } from "../modules/security/command-validator";
+import { logBashCommand, logSecurityBlock } from "../modules/security/audit-log";
 import { getSessionSecurityConfig } from "../modules/security/session-isolation";
 import { DEFAULT_SECURITY_CONFIG } from "../config/security";
-import { processRegistry, registerKillable, unregisterKillable, } from "../modules/processes";
+import { processRegistry, registerKillable, unregisterKillable } from "../modules/processes";
 import { t } from "../i18n/index";
 import { platform } from "os";
 import { MAX_PREVIEW_LINES } from "./preview";
@@ -16,11 +16,26 @@ import { MAX_PREVIEW_LINES } from "./preview";
 export const BASH_GRACE_MS = 5000;
 /** Short window for explicit `background: true` — surfaces immediate spawn failures (bad cwd, missing shell). */
 const SPAWN_SETTLE_MS = 100;
+/** Number of already-emitted lines shown in the background start message. */
+const BG_OUTPUT_PREVIEW_LINES = 15;
 let bashGraceMs = BASH_GRACE_MS;
 /** Test hook: override the auto-background grace window. */
 export function setBashGraceMs(ms) {
     bashGraceMs = ms;
 }
+/**
+ * Consecutive failures per first command word (resets on success). A model
+ * that keeps calling a forbidden Unix command in cmd.exe (head/cat/grep/...)
+ * gets a hint the first couple of times; after HARD_BLOCK_THRESHOLD consecutive
+ * failures the tool hard-stops with a STOP directive instead of repeating the
+ * same hint forever (observed: `head` called 5×, `Select-String` 3× in one run).
+ */
+const FAILING_FIRST_WORDS = new Map();
+const HARD_BLOCK_THRESHOLD = 3;
+/** Test hook: clear the consecutive-failure tracking state. */
+export function resetBashFailureTracking() {
+    FAILING_FIRST_WORDS.clear();
+}
 /**
  * Detect a file write via `echo/printf ... > file` — common model habit that
  * breaks in cmd.exe: single quotes are not grouping quotes, `>` only applies
@@ -108,6 +123,12 @@ const UNIX_TO_WIN_HINTS = {
     echo: "echo works on Windows, but avoid pipes (|).",
     "Get-Content": "Use the read_file tool instead.",
     "Select-Object": "Use the read_file tool with offset/limit instead.",
+    "Write-Host": "PowerShell cmdlet — this shell is cmd.exe. Print with plain echo instead.",
+    "Select-String": "Use the grep tool instead.",
+    "Out-File": "Write files with the write_file tool instead.",
+    "Set-Content": "Write files with the write_file tool instead.",
+    "Get-ChildItem": "Use the list_dir tool instead.",
+    "Remove-Item": "Use the delete_file tool instead.",
 };
 /** Unix commands that can be transparently translated to cmd.exe equivalents. */
 const UNIX_TO_WIN_TRANSLATE = {
@@ -198,9 +219,94 @@ export function parseToolArgs(raw) {
     }
     return args;
 }
+/**
+ * Detect a test-runner report embedded in command output (bun test / vitest /
+ * jest / mocha / `go test` / pytest). Returns null when the output does not
+ * look like a test run. Used to inject a warning when tests fail so the model
+ * cannot close a "run the tests" step as done.
+ */
+export function detectTestResults(output) {
+    if (!output)
+        return null;
+    // Framework-specific quantifiers first (unambiguous).
+    const jest = output.match(/Tests:\s+(\d+)\s+passed,\s*(\d+)\s+failed/i);
+    if (jest) {
+        return { framework: "jest", passed: +jest[1], failed: +jest[2] };
+    }
+    const mochaPass = output.match(/(\d+)\s+passing/i);
+    const mochaFail = output.match(/(\d+)\s+failing/i);
+    if (mochaPass || mochaFail) {
+        return {
+            framework: "mocha",
+            passed: mochaPass ? +mochaPass[1] : 0,
+            failed: mochaFail ? +mochaFail[1] : 0,
+        };
+    }
+    const pytest = output.match(/(\d+)\s+passed[^\n]*?(?:,\s*(\d+)\s+failed)?/i);
+    if (pytest &&
+        /pytest|passed|failed/i.test(output) &&
+        /(=====|short test summary|tests\s+ok)/i.test(output) === false &&
+        /pytest|collect/i.test(output)) {
+        return {
+            framework: "pytest",
+            passed: +pytest[1],
+            failed: pytest[2] ? +pytest[2] : 0,
+        };
+    }
+    // bun test / vitest: per-case markers + trailing "N pass / M fail".
+    const failMarkers = output.match(/\(fail\)/g)?.length ?? 0;
+    const passMarkers = output.match(/\(pass\)/g)?.length ?? 0;
+    const xMarkers = output.match(/\s×\s/g)?.length ?? 0;
+    const summaryMatch = output.match(/^\s*(\d+)\s+pass[^\n]*$/m);
+    const failSummary = output.match(/^\s*(\d+)\s+fail[^\n]*$/m);
+    const ran = output.match(/(?:Ran|ran)\s+\d+\s+tests/i);
+    if (failMarkers > 0 || passMarkers > 0 || xMarkers > 0 || ran) {
+        const failed = Math.max(failMarkers + xMarkers, failSummary ? +failSummary[1] : 0);
+        const passed = Math.max(passMarkers, summaryMatch ? +summaryMatch[1] : 0);
+        return {
+            framework: ran ? "bun/vitest" : "vitest",
+            passed,
+            failed,
+            summary: summaryMatch?.[0] ?? failSummary?.[0],
+        };
+    }
+    return null;
+}
+/**
+ * R5: a command that runs a script file (bun/node/python/...) exited 0 but
+ * printed nothing. The most common cause in agent sessions: the program has
+ * no entry point — nobody calls its main() with the CLI args. Surface a
+ * concrete hint instead of letting the model stare at an empty output.
+ */
+const CLI_FILE_RUN_RE = /\b(bun|node|deno|python|python3|tsx|ts-node|php|ruby|go\s+run)\S*\s+(run\s+)?["']?[\w./\\-]+\.(ts|js|tsx|jsx|mjs|cjs|py)\b/;
+export function emptyCliRunHint(command, output, code) {
+    if (code !== 0 || output.trim())
+        return null;
+    if (/[>|]/.test(command))
+        return null; // redirection/pipes — output went elsewhere
+    if (/\b(bun test|vitest|pytest|jest|mocha|--test)\b/i.test(command))
+        return null;
+    if (!CLI_FILE_RUN_RE.test(command))
+        return null;
+    return "the command exited 0 but printed NOTHING to stdout. If this should run a CLI program, the file probably has no entry point: read it with read_file and check the code actually calls its main function with command-line arguments (e.g. main(process.argv[2])) and prints results with console.log.";
+}
+/**
+ * Detect npm/npx/bunx failing with "could not determine executable to run"
+ * — the package declares no `bin` (or `npm run <script>` named a missing
+ * script). Append a concrete hint instead of letting the model re-try blindly
+ * (observed in two agent sessions: the model burned many iterations re-running
+ * the same failing `npx`/`bunx`/`npm run` command).
+ */
+const NPM_EXEC_RE = /could not determine executable to run/i;
+export function npmExecHint(output) {
+    if (NPM_EXEC_RE.test(output)) {
+        return `${output}\n\nHint: ${t("exec.npm_exec_hint")}`;
+    }
+    return output;
+}
 export const bashTool = {
     name: "bash",
-    description: "Execute a shell command and return its output. Use for running tests, build, git, and shell operations. Commands that are still running after a few seconds are automatically moved to the background and return a process id — manage them with process_list, process_log, process_kill. Set background=true to return a process id immediately for commands you know are long-running (dev servers, watchers).",
+    description: "Execute a shell command and return its output. Use for running tests, build, git, and shell operations. Commands that are still running after a few seconds are automatically moved to the background and return a process id — manage them with process_list, process_log, process_kill. Set background=true to return a process id immediately for commands you know are long-running (dev servers, watchers).\n\nWindows notes: the shell is cmd.exe — PowerShell cmdlets (Write-Host, Get-Content, Select-String, Out-File) and bash heredocs (cat << EOF) do NOT work there. Use the read_file/write_file tools instead of cat/echo redirection. Sequential commands: use && (a leading ; is auto-converted to &).",
     tags: ["shell", "code"],
     parameters: {
         type: "object",
@@ -287,19 +393,55 @@ export const bashTool = {
                 const code = entry.exitCode;
                 let output = entry.log.join("\n");
                 processRegistry.remove(entry.id);
+                // R5: script file ran with exit 0 but empty output — likely a
+                // missing entry point (main is never called with argv).
+                const cliHint = emptyCliRunHint(command, output, code);
+                if (cliHint) {
+                    output = `(exit code 0, no output)\n\nHint: ${cliHint}`;
+                }
+                // Auto-verify test runs: a failing suite must not be reported as a
+                // clean success. Inject a prominent marker the model cannot miss
+                // (the tpical failure: tests fail but the CLI exit code is 0).
+                const testRun = detectTestResults(output);
+                if (testRun && testRun.failed > 0) {
+                    output =
+                        `[test-runner] ${testRun.framework}: ${testRun.failed} test(s) FAILING, ${testRun.passed} passing — do NOT mark verification steps as done while tests fail. Investigate the failures, fix the code, then re-run the tests.\n\n` +
+                            output;
+                }
+                else if (testRun && testRun.failed === 0 && testRun.passed > 0) {
+                    output = `[test-runner] ${testRun.framework}: all ${testRun.passed} test(s) passing.\n\n${output}`;
+                }
                 if (!output && code !== 0) {
                     output = `(exit code ${code})`;
                 }
-                // On Windows, hint about Unix commands that don't work
-                if (platform() === "win32" && code !== 0) {
-                    const firstWord = command
-                        .trim()
-                        .split(/\s+/)[0]
-                        ?.split(/[\\/]/)
-                        .pop();
-                    const hint = firstWord ? UNIX_TO_WIN_HINTS[firstWord] : undefined;
-                    if (hint) {
-                        output = `${output}\n\nHint: "${firstWord}" may not work on Windows. ${hint}`;
+                // npm/npx/bunx: "could not determine executable to run" — the
+                // package has no `bin` entry (or the script does not exist).
+                // This is cross-platform, so it runs before the win32 hint block.
+                output = npmExecHint(output);
+                // On Windows, hint about Unix commands that don't work, and
+                // hard-stop a command that keeps failing the same way. The
+                // hint keys on the ORIGINAL command word (before
+                // adaptCommandForWindows translated cat→type): the translation
+                // is only for execution, but the model wrote `cat`, and that is
+                // what UNIX_TO_WIN_HINTS knows about. Keying on the translated
+                // word left `cat` invisible to the hint/block (observed: model
+                // ran cat 4+ times in one session with no guidance).
+                if (platform() === "win32") {
+                    const originalFirstWord = originalCommand.trim().split(/\s+/)[0]?.split(/[\\/]/).pop();
+                    if (originalFirstWord && originalFirstWord in UNIX_TO_WIN_HINTS) {
+                        if (code === 0) {
+                            FAILING_FIRST_WORDS.delete(originalFirstWord);
+                        }
+                        else {
+                            const failures = (FAILING_FIRST_WORDS.get(originalFirstWord) || 0) + 1;
+                            FAILING_FIRST_WORDS.set(originalFirstWord, failures);
+                            if (failures >= HARD_BLOCK_THRESHOLD) {
+                                output = `STOP using "${originalFirstWord}" — it does not work in this cmd.exe shell and has failed ${failures} times in a row. ${UNIX_TO_WIN_HINTS[originalFirstWord]}`;
+                            }
+                            else {
+                                output = `${output}\n\nHint: "${originalFirstWord}" may not work on Windows. ${UNIX_TO_WIN_HINTS[originalFirstWord]}`;
+                            }
+                        }
                     }
                 }
                 // Update audit log with result
@@ -307,7 +449,18 @@ export const bashTool = {
                     logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), code === 0, `Working directory: ${workdir}, Output length: ${output.length}`);
                 }
                 const lines = output.split("\n");
-                if (lines.length > MAX_PREVIEW_LINES) {
+                if (testRun && testRun.failed > 0) {
+                    // Keep the failure details: test runners print passing markers
+                    // first and the errors + summary at the very end. A short head
+                    // preview hides exactly what the model needs to fix the failures.
+                    const TEST_TAIL_LINES = 400;
+                    const kept = lines.slice(-TEST_TAIL_LINES);
+                    const skipped = lines.length - kept.length;
+                    output =
+                        (skipped > 0 ? `[... ${skipped} earlier lines omitted — failing tests below]\n` : "") +
+                            kept.join("\n");
+                }
+                else if (lines.length > MAX_PREVIEW_LINES) {
                     output =
                         lines.slice(0, MAX_PREVIEW_LINES).join("\n") +
                             `\n... (${lines.length - MAX_PREVIEW_LINES} more lines)`;
@@ -316,13 +469,19 @@ export const bashTool = {
             }
             // Still running — promote to a background process.
             const explicit = args.background === true;
-            const output = `${t("proc.started", {
+            const preview = entry.log
+                .filter((l) => l.trim() !== "")
+                .slice(0, BG_OUTPUT_PREVIEW_LINES)
+                .join("\n");
+            let output = `${t("proc.started", {
                 id: entry.id,
                 pid: entry.pid,
                 command,
-            })}${explicit ? "" : `\n${t("proc.promoted_hint", { ms: settleMs })}`}\n${t("proc.manage_hint", {
-                id: entry.id,
-            })}`;
+            })}${explicit ? "" : `\n${t("proc.promoted_hint", { ms: settleMs })}`}`;
+            if (preview) {
+                output += `\n\n${t("proc.output_preview", { lines: preview })}`;
+            }
+            output += `\n${t("proc.manage_hint", { id: entry.id })}`;
             if (securityConfig?.logCommands) {
                 logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), true, `Started in background: ${entry.id} (PID ${entry.pid})`);
             }

package/dist/tools/browser.js

@@ -1,15 +1,18 @@
-import { BrowserSession } from '../modules/browser/session';
-import { DEFAULT_BROWSER_CONFIG } from '../modules/browser/types';
-import { t } from '../i18n/index';
-import { join } from 'path';
+import { BrowserSession } from "../modules/browser/session";
+import { DEFAULT_BROWSER_CONFIG } from "../modules/browser/types";
+import { t } from "../i18n/index";
+import { join } from "path";
 let session = null;
 function getSession(ctx) {
     if (!session) {
-        const cookieDir = join(ctx.baseDir, '.mma', 'browser');
+        const cookieDir = join(ctx.baseDir, ".mma", "browser");
         session = new BrowserSession({
             ...DEFAULT_BROWSER_CONFIG,
             headless: ctx.config.browser?.headless ?? true,
             maxElements: ctx.config.browser?.maxElements ?? 30,
+            maxContentChars: ctx.config.browser?.maxContentChars ?? 2500,
+            maxConsoleEntries: ctx.config.browser?.maxConsoleEntries ?? 40,
+            maxConsoleLineChars: ctx.config.browser?.maxConsoleLineChars ?? 400,
             navigationTimeout: ctx.config.browser?.navigationTimeout ?? 15000,
             viewportWidth: ctx.config.browser?.viewportWidth ?? 1280,
             viewportHeight: ctx.config.browser?.viewportHeight ?? 720,
@@ -19,66 +22,80 @@ function getSession(ctx) {
     return session;
 }
 export function formatScreenshotForTextModel(snapshot) {
-    return `${t('tool.screenshot_unavailable')}\n\n${snapshot}`;
+    return `${t("tool.screenshot_unavailable")}\n\n${snapshot}`;
 }
 export function formatScreenshotResult(snapshot, screenshot, supportsVision) {
     if (!supportsVision) {
         return formatScreenshotForTextModel(snapshot);
     }
-    const base64 = screenshot.toString('base64');
+    const base64 = screenshot.toString("base64");
     return `${snapshot}\n\n[Screenshot: data:image/png;base64,${base64}]`;
 }
 export function createBrowserTool() {
     return {
-        name: 'browser',
-        tags: ['browser', 'vision'],
+        name: "browser",
+        tags: ["browser", "vision"],
         description: [
-            'Control a headless browser. Navigate pages, click elements, type text, scroll, take screenshots.',
-            'Returns a numbered list of interactive elements — use element numbers as targets for click/type.',
-            'Actions: open (url), click (target), type (target, text), scroll (direction), back, forward, screenshot, snapshot, close, wait (ms).',
-        ].join(' '),
+            "Control a headless browser. Navigate pages, click elements, type text, scroll, take screenshots.",
+            "Runs a real browser with JavaScript enabled — use it for JS-rendered sites (weather, dashboards, SPAs) where web_fetch/web_browse return empty content.",
+            "Do NOT use it for search queries: search engines (Google, Yandex, Bing) block headless browsers with CAPTCHA/429/redirect pages — use the web_search tool for searching.",
+            "Each snapshot returns: a numbered list of interactive elements, the visible page text (Content section), browser console messages, and network errors.",
+            "Use the Content section to understand what the page says; use element numbers as targets for click/type.",
+            "Actions: open (url), click (target), type (target, text), scroll (direction), back, forward, screenshot, snapshot, close, wait (ms).",
+        ].join(" "),
         parameters: {
-            type: 'object',
+            type: "object",
             properties: {
                 action: {
-                    type: 'string',
-                    enum: ['open', 'click', 'type', 'scroll', 'back', 'forward', 'screenshot', 'snapshot', 'close', 'wait'],
-                    description: 'Browser action to perform',
+                    type: "string",
+                    enum: [
+                        "open",
+                        "click",
+                        "type",
+                        "scroll",
+                        "back",
+                        "forward",
+                        "screenshot",
+                        "snapshot",
+                        "close",
+                        "wait",
+                    ],
+                    description: "Browser action to perform",
                 },
                 url: {
-                    type: 'string',
+                    type: "string",
                     description: 'URL to open (for action "open")',
                 },
                 target: {
-                    type: 'number',
+                    type: "number",
                     description: 'Element number from snapshot (for action "click" or "type")',
                 },
                 text: {
-                    type: 'string',
+                    type: "string",
                     description: 'Text to type (for action "type")',
                 },
                 direction: {
-                    type: 'string',
-                    enum: ['up', 'down', 'top', 'bottom'],
+                    type: "string",
+                    enum: ["up", "down", "top", "bottom"],
                     description: 'Scroll direction (for action "scroll", default "down")',
                 },
                 ms: {
-                    type: 'number',
+                    type: "number",
                     description: 'Milliseconds to wait (for action "wait", default 1000)',
                 },
             },
-            required: ['action'],
+            required: ["action"],
         },
         handler: async (ctx, args) => {
-            const action = String(args.action || '');
+            const action = String(args.action || "");
             if (!action) {
-                return { success: false, output: t('tool.action_required') };
+                return { success: false, output: t("tool.action_required") };
             }
             const s = getSession(ctx);
             const result = await s.execute(action, args);
-            const supportsVision = ctx.config.model.includes('vision') ||
-                ctx.config.model.includes('gpt-4o') ||
-                ctx.config.model.includes('claude');
+            const supportsVision = ctx.config.model.includes("vision") ||
+                ctx.config.model.includes("gpt-4o") ||
+                ctx.config.model.includes("claude");
             if (result.screenshot) {
                 return {
                     success: result.success,