micro-models-agent 0.63.0 → 1.1.0

package/dist/modules/mcp/module.js

@@ -1,5 +1,7 @@
 import { MCPClient } from "./client";
 import { MCPRegistry } from "./registry";
+import { Logger } from "../../logger/app-logger";
+const logger = new Logger("warn", "mcp");
 function sanitizeToolName(server, tool) {
     const safeServer = server.replace(/[^a-zA-Z0-9_-]/g, "_");
     const safeTool = tool.replace(/[^a-zA-Z0-9_-]/g, "_");
@@ -16,16 +18,27 @@ function convertInputSchema(schema) {
     }
     return { type: "object", properties: {} };
 }
+/** Timeout for the initial tool discovery call (avoids hanging startup). */
+const DISCOVERY_TIMEOUT_MS = 5_000;
 export class MCPModule {
     config;
     name = "mcp";
     connections = new Map();
+    /** Server configs registered at init, not yet connected. */
+    serverConfigs = new Map();
     discovered = [];
     initialized = false;
     initError = null;
+    /** Servers that failed initial discovery — will not be retried. */
+    failedServers = new Set();
     constructor(config) {
         this.config = config;
     }
+    /**
+     * Register MCP server configs WITHOUT connecting. Actual connection and tool
+     * discovery happens lazily on first tool call — keeps startup fast and
+     * offline-safe.
+     */
     async initialize() {
         if (this.initialized)
             return;
@@ -48,14 +61,76 @@ export class MCPModule {
             };
             registry.register(serverConfig);
         }
+        // Store configs for lazy connection — no network calls here.
         for (const serverName of registry.list()) {
-            const serverConfig = registry.get(serverName);
+            this.serverConfigs.set(serverName, registry.get(serverName));
+        }
+        // Attempt fast discovery in background (best-effort, timeout-bounded).
+        // If it fails, tools are still registered — they'll connect on first call.
+        this.discoverAllTools();
+    }
+    /**
+     * Try to connect and discover tools for all registered servers.
+     * Runs in background, never blocks the caller. Failures are silent —
+     * tools still get registered and will retry connection on first call.
+     */
+    async discoverAllTools() {
+        for (const [serverName, serverConfig] of this.serverConfigs) {
+            if (this.failedServers.has(serverName))
+                continue;
             const client = new MCPClient(serverConfig);
             try {
-                await client.connect();
-                const tools = await client.listTools();
-                this.connections.set(serverName, client);
-                for (const tool of tools) {
+                // Race discovery against timeout — never let a dead server block startup.
+                await Promise.race([
+                    (async () => {
+                        await client.connect();
+                        const tools = await client.listTools();
+                        this.connections.set(serverName, client);
+                        for (const tool of tools) {
+                            this.discovered.push({
+                                serverName,
+                                toolName: tool.name,
+                                description: tool.description || `Tool on MCP server "${serverName}"`,
+                                inputSchema: tool.inputSchema || {},
+                            });
+                        }
+                    })(),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("discovery timeout")), DISCOVERY_TIMEOUT_MS)),
+                ]);
+            }
+            catch (e) {
+                this.failedServers.add(serverName);
+                this.initError = `MCP server "${serverName}" init failed: ${e.message}`;
+                await client.disconnect().catch((err) => {
+                    logger.warn(`cleanup disconnect for "${serverName}" failed`, { error: String(err) });
+                });
+            }
+        }
+    }
+    /**
+     * Ensure a specific server is connected and its tools are discovered.
+     * Called lazily on first tool invocation for that server.
+     */
+    async ensureConnected(serverName) {
+        // Already connected?
+        const existing = this.connections.get(serverName);
+        if (existing?.isConnected())
+            return existing;
+        // Failed during init — don't retry.
+        if (this.failedServers.has(serverName))
+            return null;
+        const serverConfig = this.serverConfigs.get(serverName);
+        if (!serverConfig)
+            return null;
+        const client = new MCPClient(serverConfig);
+        try {
+            await client.connect();
+            const tools = await client.listTools();
+            this.connections.set(serverName, client);
+            // Add newly discovered tools (if not already present).
+            for (const tool of tools) {
+                const alreadyDiscovered = this.discovered.some((d) => d.serverName === serverName && d.toolName === tool.name);
+                if (!alreadyDiscovered) {
                     this.discovered.push({
                         serverName,
                         toolName: tool.name,
@@ -64,14 +139,18 @@ export class MCPModule {
                     });
                 }
             }
-            catch (e) {
-                this.initError = `MCP server "${serverName}" init failed: ${e.message}`;
-                await client.disconnect().catch(() => { });
-            }
+            return client;
+        }
+        catch (e) {
+            this.failedServers.add(serverName);
+            logger.warn(`MCP connect failed for "${serverName}": ${e.message}`);
+            await client.disconnect().catch(() => { });
+            return null;
         }
     }
     getSystemPromptBlock() {
-        if (this.discovered.length === 0)
+        const serverNames = [...this.serverConfigs.keys()];
+        if (serverNames.length === 0)
             return null;
         const lines = ["---", "MCP servers available:"];
         const byServer = new Map();
@@ -80,11 +159,17 @@ export class MCPModule {
             list.push(d);
             byServer.set(d.serverName, list);
         }
-        for (const [server, tools] of byServer) {
-            lines.push(`  [${server}]`);
-            for (const t of tools) {
-                const toolRef = sanitizeToolName(server, t.toolName);
-                lines.push(`    - ${toolRef}: ${t.description}`);
+        for (const serverName of serverNames) {
+            lines.push(`  [${serverName}]`);
+            const tools = byServer.get(serverName);
+            if (tools && tools.length > 0) {
+                for (const t of tools) {
+                    const toolRef = sanitizeToolName(serverName, t.toolName);
+                    lines.push(`    - ${toolRef}: ${t.description}`);
+                }
+            }
+            else {
+                lines.push(`    (not yet connected — use mcp__${serverName}__connect to discover tools)`);
             }
         }
         lines.push("---");
@@ -96,45 +181,84 @@ export class MCPModule {
         };
     }
     getToolDefinitions() {
-        return this.discovered.map((d) => ({
-            name: sanitizeToolName(d.serverName, d.toolName),
-            description: `${d.description} [MCP server: ${d.serverName}]`,
-            parameters: convertInputSchema(d.inputSchema),
-            tags: ["code", "research"],
-            handler: async (_ctx, args) => {
-                const client = this.connections.get(d.serverName);
-                if (!client) {
-                    return {
-                        success: false,
-                        output: `MCP server "${d.serverName}" not connected`,
-                    };
-                }
-                try {
-                    if (!client.isConnected()) {
-                        await client.connect();
+        // Build definitions from discovered tools AND from registered-but-not-yet-discovered
+        // servers (so the LLM sees all configured MCP tools even if discovery failed at startup).
+        const defs = [];
+        // Tools already discovered (connected at startup).
+        for (const d of this.discovered) {
+            defs.push({
+                name: sanitizeToolName(d.serverName, d.toolName),
+                description: `${d.description} [MCP server: ${d.serverName}]`,
+                parameters: convertInputSchema(d.inputSchema),
+                tags: ["code", "research"],
+                handler: async (_ctx, args) => {
+                    const client = this.connections.get(d.serverName);
+                    if (!client?.isConnected()) {
+                        return {
+                            success: false,
+                            output: `MCP server "${d.serverName}" not connected`,
+                        };
+                    }
+                    try {
+                        const result = await client.callTool(d.toolName, args);
+                        return {
+                            success: true,
+                            output: typeof result === "string" ? result : JSON.stringify(result, null, 2),
+                        };
                     }
-                    const result = await client.callTool(d.toolName, args);
+                    catch (e) {
+                        return { success: false, output: `MCP call failed: ${e.message}` };
+                    }
+                },
+            });
+        }
+        // Servers that haven't been discovered yet — register placeholder tools
+        // that will connect lazily on first call.
+        for (const [serverName] of this.serverConfigs) {
+            if (this.failedServers.has(serverName))
+                continue;
+            const alreadyDiscovered = this.discovered.some((d) => d.serverName === serverName);
+            if (alreadyDiscovered)
+                continue;
+            // Register a single "connect" tool so the LLM can trigger discovery.
+            defs.push({
+                name: sanitizeToolName(serverName, "connect"),
+                description: `Connect to MCP server "${serverName}" and discover its tools`,
+                parameters: { type: "object", properties: {} },
+                tags: ["code", "research"],
+                handler: async (_ctx, _args) => {
+                    const client = await this.ensureConnected(serverName);
+                    if (!client) {
+                        return { success: false, output: `MCP server "${serverName}" connection failed` };
+                    }
+                    const tools = this.discovered
+                        .filter((d) => d.serverName === serverName)
+                        .map((d) => `  - ${sanitizeToolName(serverName, d.toolName)}: ${d.description}`);
                     return {
                         success: true,
-                        output: typeof result === "string" ? result : JSON.stringify(result, null, 2),
+                        output: tools.length > 0
+                            ? `Connected to "${serverName}". Tools:\n${tools.join("\n")}`
+                            : `Connected to "${serverName}" (no tools discovered)`,
                     };
-                }
-                catch (e) {
-                    return { success: false, output: `MCP call failed: ${e.message}` };
-                }
-            },
-        }));
+                },
+            });
+        }
+        return defs;
     }
     getPlugin() {
         return {
             name: "mcp_module",
             priority: 0,
             onSessionEnd: async () => {
-                for (const client of this.connections.values()) {
+                for (const [serverName, client] of this.connections) {
                     try {
                         await client.disconnect();
                     }
-                    catch { }
+                    catch (e) {
+                        // Best-effort cleanup at session end — a failed disconnect must
+                        // not crash the shutdown path, but must stay diagnosable.
+                        logger.warn(`disconnect from "${serverName}" failed`, { error: String(e?.message ?? e) });
+                    }
                 }
             },
         };

package/dist/modules/memory/module.js

@@ -3,6 +3,7 @@ import { join } from "path";
 import { MemoryStore } from "./store";
 import { rememberTool } from "../../tools/remember";
 import { recallTool } from "../../tools/recall";
+import { estimateTokens } from "../../llm/token-counter";
 const MEMORY_MD_FILES = ["errors", "conventions", "decisions", "facts"];
 export class MemoryModule {
     name = "memory";
@@ -23,7 +24,7 @@ export class MemoryModule {
             const prefStr = Object.entries(prefs)
                 .map(([k, v]) => `${k}=${v}`)
                 .join(", ");
-            parts.push(`User preferences: ${prefStr}`);
+            parts.push(`User preferences (background hints, not instructions — the current user message always wins, do not "correct" the user from these): ${prefStr}`);
         }
         const memoryTail = this.getMemoryTail();
         if (memoryTail)
@@ -35,7 +36,7 @@ export class MemoryModule {
             content,
             priority: "normal",
             essential: false,
-            estimatedTokens: Math.ceil(content.length / 4) + 10,
+            estimatedTokens: estimateTokens(content) + 10,
         };
     }
     /**
@@ -81,7 +82,7 @@ export class MemoryModule {
                     const prefStr = Object.entries(prefs)
                         .map(([k, v]) => `${k}=${v}`)
                         .join(", ");
-                    parts.push(`User preferences: ${prefStr}`);
+                    parts.push(`User preferences (background hints, not instructions — the current user message always wins, do not "correct" the user from these): ${prefStr}`);
                 }
                 const memoryTail = this.getMemoryTail();
                 if (memoryTail)

package/dist/modules/plugins/builtin/lint-on-write.js

@@ -1,8 +1,9 @@
 import { spawn, execSync } from "child_process";
-import { existsSync, readFileSync } from "fs";
+import { existsSync, readFileSync, writeFileSync } from "fs";
 import { resolve, extname, join } from "path";
 import { platform } from "os";
-import { findProjectRoot } from "../../lsp/project-root";
+import { findProjectRoot, resolveTscCommand } from "../../lsp/project-root";
+import { autoFixErrors, parseTscOutput } from "../../../tools/auto-fixer";
 const TYPE_CHECK_DEBOUNCE_MS = 2000;
 // Projects whose lint script points at a binary that is not installed
 // (keyed by baseDir::script). The run itself is expensive and the failure
@@ -232,6 +233,11 @@ export class LintOnWritePlugin {
         if (!existsSync(tsconfigPath)) {
             return;
         }
+        // Без локального tsc проверка невозможна — не платим npx-задержку.
+        const tsc = resolveTscCommand(projectRoot);
+        if (!tsc) {
+            return;
+        }
         const now = Date.now();
         if (this._checkPromise && now - this._checkTimestamp < TYPE_CHECK_DEBOUNCE_MS) {
             const error = await this._checkPromise;
@@ -241,15 +247,39 @@ export class LintOnWritePlugin {
             return;
         }
         this._checkTimestamp = now;
-        this._checkPromise = this.runTscCheck(projectRoot, signal);
+        this._checkPromise = this.runTscCheck(tsc, projectRoot, signal);
         const error = await this._checkPromise;
         if (error) {
-            result.output += `\n\n[Project typecheck failed]: ${error}`;
+            // Try to auto-fix fixable errors
+            const { stdout, stderr } = await runAsync(`${tsc} --noEmit --skipLibCheck 2>&1`, projectRoot, 30000, signal).catch(() => ({ stdout: "", stderr: error }));
+            const output = stderr || stdout;
+            const errors = parseTscOutput(output);
+            if (errors.length > 0) {
+                const fixResult = autoFixErrors(filePath, readFileSync(filePath, "utf-8"), errors);
+                if (fixResult.fixed) {
+                    // Write the fixed content
+                    writeFileSync(filePath, fixResult.newContent, "utf-8");
+                    result.output += `\n\n[Auto-fixed]: ${fixResult.applied.join("; ")}`;
+                    // If there are remaining errors, show them
+                    if (fixResult.remaining.length > 0) {
+                        const remainingMsg = fixResult.remaining
+                            .map((e) => `TS${e.code}: ${e.message}`)
+                            .join("\n");
+                        result.output += `\n\n[Remaining errors]: ${remainingMsg}`;
+                    }
+                }
+                else {
+                    result.output += `\n\n[Project typecheck failed]: ${error}`;
+                }
+            }
+            else {
+                result.output += `\n\n[Project typecheck failed]: ${error}`;
+            }
         }
     }
-    async runTscCheck(baseDir, signal) {
+    async runTscCheck(tsc, baseDir, signal) {
         try {
-            await runAsync(`npx tsc --noEmit --skipLibCheck`, baseDir, 30000, signal);
+            const { stdout, stderr } = await runAsync(`${tsc} --noEmit --skipLibCheck`, baseDir, 30000, signal);
             return null;
         }
         catch (err) {

package/dist/modules/plugins/manager.js

@@ -1,4 +1,29 @@
 import { semverGt } from "../updater/checker";
+import { Logger } from "../../logger/app-logger";
+const logger = new Logger("warn", "plugins");
+/**
+ * Run a (possibly async) plugin hook with error isolation. Sync throws and
+ * async rejections are both logged and swallowed — one broken plugin must
+ * never crash the agent or other plugins.
+ */
+function safeInvoke(plugin, hookName, fn) {
+    try {
+        const out = fn();
+        if (out instanceof Promise) {
+            // The promise rejects AFTER this try/catch has exited — attach a catch
+            // now, otherwise isolation is broken by an unhandledRejection.
+            out.catch((e) => {
+                logger.warn(`plugin "${plugin.name}" ${hookName} rejected`, { error: String(e) });
+            });
+            return undefined;
+        }
+        return out;
+    }
+    catch (e) {
+        logger.warn(`plugin "${plugin.name}" ${hookName} threw`, { error: String(e) });
+        return undefined;
+    }
+}
 export class PluginManager {
     plugins = [];
     hostBridge = null;
@@ -55,14 +80,7 @@ export class PluginManager {
         return this.plugins.find((p) => p.name === name) ?? null;
     }
     runOnBuildPrompt() {
-        return this.plugins.map((p) => {
-            try {
-                return p.onBuildPrompt?.() ?? null;
-            }
-            catch {
-                return null;
-            }
-        });
+        return this.plugins.map((p) => safeInvoke(p, "onBuildPrompt", () => p.onBuildPrompt?.() ?? null) ?? null);
     }
     async runOnBeforeTool(rawCtx, call) {
         const ctx = this.withHost(rawCtx);
@@ -73,8 +91,8 @@ export class PluginManager {
                     if (result === false)
                         return false;
                 }
-                catch {
-                    /* error isolation */
+                catch (e) {
+                    logger.warn(`plugin "${plugin.name}" onBeforeTool failed`, { error: String(e) });
                 }
             }
         }
@@ -87,8 +105,8 @@ export class PluginManager {
                 try {
                     await plugin.onAfterTool(ctx, call, result);
                 }
-                catch {
-                    /* error isolation */
+                catch (e) {
+                    logger.warn(`plugin "${plugin.name}" onAfterTool failed`, { error: String(e) });
                 }
             }
         }
@@ -100,8 +118,8 @@ export class PluginManager {
                 try {
                     await plugin.onError(ctx, error);
                 }
-                catch {
-                    /* error isolation */
+                catch (e) {
+                    logger.warn(`plugin "${plugin.name}" onError failed`, { error: String(e) });
                 }
             }
         }
@@ -110,12 +128,7 @@ export class PluginManager {
         const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onSessionStart) {
-                try {
-                    plugin.onSessionStart(ctx);
-                }
-                catch {
-                    /* error isolation */
-                }
+                safeInvoke(plugin, "onSessionStart", () => plugin.onSessionStart(ctx));
             }
         }
     }
@@ -123,12 +136,7 @@ export class PluginManager {
         const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onBeforeThink) {
-                try {
-                    plugin.onBeforeThink(ctx);
-                }
-                catch {
-                    /* error isolation */
-                }
+                safeInvoke(plugin, "onBeforeThink", () => plugin.onBeforeThink(ctx));
             }
         }
     }
@@ -136,12 +144,7 @@ export class PluginManager {
         const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onAfterThink) {
-                try {
-                    plugin.onAfterThink(ctx, response);
-                }
-                catch {
-                    /* error isolation */
-                }
+                safeInvoke(plugin, "onAfterThink", () => plugin.onAfterThink(ctx, response));
             }
         }
     }
@@ -149,12 +152,7 @@ export class PluginManager {
         const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onSessionEnd) {
-                try {
-                    plugin.onSessionEnd(ctx);
-                }
-                catch {
-                    /* error isolation */
-                }
+                safeInvoke(plugin, "onSessionEnd", () => plugin.onSessionEnd(ctx));
             }
         }
     }
@@ -162,12 +160,7 @@ export class PluginManager {
         const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onToolCall) {
-                try {
-                    plugin.onToolCall(ctx);
-                }
-                catch {
-                    /* error isolation */
-                }
+                safeInvoke(plugin, "onToolCall", () => plugin.onToolCall(ctx));
             }
         }
     }
@@ -175,12 +168,7 @@ export class PluginManager {
         const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onPhase) {
-                try {
-                    plugin.onPhase(ctx, phase);
-                }
-                catch {
-                    /* error isolation */
-                }
+                safeInvoke(plugin, "onPhase", () => plugin.onPhase(ctx, phase));
             }
         }
     }
@@ -188,12 +176,7 @@ export class PluginManager {
         const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onToolStart) {
-                try {
-                    plugin.onToolStart(ctx, call);
-                }
-                catch {
-                    /* error isolation */
-                }
+                safeInvoke(plugin, "onToolStart", () => plugin.onToolStart(ctx, call));
             }
         }
     }
@@ -201,12 +184,7 @@ export class PluginManager {
         const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onToolEnd) {
-                try {
-                    plugin.onToolEnd(ctx, call, result, durationMs);
-                }
-                catch {
-                    /* error isolation */
-                }
+                safeInvoke(plugin, "onToolEnd", () => plugin.onToolEnd(ctx, call, result, durationMs));
             }
         }
     }
@@ -215,14 +193,9 @@ export class PluginManager {
         const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onText) {
-                try {
-                    const out = plugin.onText(ctx, chunk);
-                    if (typeof out === "string")
-                        chunk = out;
-                }
-                catch {
-                    /* error isolation */
-                }
+                const out = safeInvoke(plugin, "onText", () => plugin.onText(ctx, chunk));
+                if (typeof out === "string")
+                    chunk = out;
             }
         }
         return chunk;
@@ -232,14 +205,9 @@ export class PluginManager {
         const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onMeta) {
-                try {
-                    const out = plugin.onMeta(ctx, chunk);
-                    if (typeof out === "string")
-                        chunk = out;
-                }
-                catch {
-                    /* error isolation */
-                }
+                const out = safeInvoke(plugin, "onMeta", () => plugin.onMeta(ctx, chunk));
+                if (typeof out === "string")
+                    chunk = out;
             }
         }
         return chunk;
@@ -249,12 +217,7 @@ export class PluginManager {
         const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onTurnEnd) {
-                try {
-                    plugin.onTurnEnd(ctx, summary);
-                }
-                catch {
-                    /* error isolation */
-                }
+                safeInvoke(plugin, "onTurnEnd", () => plugin.onTurnEnd(ctx, summary));
             }
         }
     }

package/dist/modules/pricing/index.js

@@ -1,4 +1,4 @@
-import { calculateCost, formatCost } from "./prices";
+import { calculateCostDetailed, formatCost } from "./prices";
 /**
  * Accumulates per-call LLM cost for a session, attributed to the provider
  * that served the call. Call `record()` after each LLM call with the
@@ -10,6 +10,7 @@ export class CostTracker {
     config;
     model;
     _total = 0;
+    _saved = 0;
     _known = false;
     byProvider = new Map();
     constructor(model, config) {
@@ -20,26 +21,35 @@ export class CostTracker {
     setModel(model) {
         this.model = model;
     }
-    /** Record a single LLM call's token usage, attributed to `provider`. */
-    record(promptTokens, completionTokens, provider) {
+    /**
+     * Записывает usage одного LLM-вызова с атрибуцией провайдеру. `cache`
+     * разделяет prompt-токены на кешированные/некешированные и накапливает
+     * экономию.
+     */
+    record(promptTokens, completionTokens, provider, cache) {
         const key = provider || "unknown";
-        const cost = calculateCost(this.model, promptTokens, completionTokens, this.config);
-        if (cost === undefined)
+        const result = calculateCostDetailed(this.model, promptTokens, completionTokens, this.config, cache);
+        if (!result)
             return;
         this._known = true;
-        this._total += cost;
+        this._total += result.cost;
+        this._saved += result.saved;
         let entry = this.byProvider.get(key);
         if (!entry) {
             entry = { total: 0, known: false };
             this.byProvider.set(key, entry);
         }
         entry.known = true;
-        entry.total += cost;
+        entry.total += result.cost;
     }
     /** Running total cost in USD, or undefined if no model price is known. */
     get total() {
         return this._known ? this._total : undefined;
     }
+    /** Накопленная экономия на cache read (USD), undefined без известной цены. */
+    get saved() {
+        return this._known ? this._saved : undefined;
+    }
     /** Total for one provider, or undefined when nothing was priced for it. */
     totalFor(provider) {
         const entry = this.byProvider.get(provider);