micro-models-agent 0.57.0 → 0.57.1

package/dist/modules/processes/registry.js

@@ -0,0 +1,327 @@
+import { spawn, spawnSync } from "child_process";
+import { platform } from "os";
+const MAX_LOG_LINES = 2000;
+const MAX_KEPT_PROCESSES = 20;
+let seq = 0;
+/** OEM decoder (Russian CP866 / active code page) — cached after first use. */
+let oemDecoder;
+function getOemDecoder() {
+    if (oemDecoder !== undefined)
+        return oemDecoder;
+    oemDecoder = null;
+    try {
+        const cpOut = spawnSync("chcp.com", {
+            encoding: "buffer",
+            timeout: 2000,
+            windowsHide: true,
+        }).stdout;
+        const m = cpOut ? cpOut.toString("latin1").match(/(\d+)/) : null;
+        if (m) {
+            try {
+                oemDecoder = new TextDecoder("ibm" + m[1]);
+            }
+            catch {
+                oemDecoder = null;
+            }
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    if (!oemDecoder) {
+        try {
+            oemDecoder = new TextDecoder("ibm866");
+        }
+        catch {
+            oemDecoder = null;
+        }
+    }
+    return oemDecoder;
+}
+/**
+ * Decode one complete line of output to UTF-8.
+ *
+ * Modern tools (Bun, Node, npm, git) write UTF-8 into the pipe regardless of
+ * the console code page, while built-in cmd.exe commands (echo, type, dir)
+ * emit the OEM code page (CP866 on Russian Windows). Try strict UTF-8 first;
+ * fall back to the OEM decoder when the bytes are not valid UTF-8.
+ */
+function decodeLineToUtf8(buf) {
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(buf);
+    }
+    catch {
+        /* not valid UTF-8 → OEM code page output */
+    }
+    const oem = getOemDecoder();
+    if (oem) {
+        try {
+            return oem.decode(buf);
+        }
+        catch {
+            /* unknown encoding — latin1 fallback */
+        }
+    }
+    return buf.toString("latin1");
+}
+/** Synchronous pause without blocking the event loop (via Atomics.wait). */
+function sleepSync(ms) {
+    try {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+    }
+    catch {
+        /* ignore */
+    }
+}
+function taskkillPid(pid) {
+    try {
+        spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], {
+            windowsHide: true,
+            stdio: "ignore",
+            timeout: 5000,
+        });
+    }
+    catch {
+        /* already dead */
+    }
+}
+/**
+ * Kill a spawned tree on Windows.
+ *
+ * `taskkill /T` has a race: when cmd.exe is killed, a child (node) that is
+ * still starting up can survive as an orphan because it was never attached to
+ * the tree at kill time. A single pass misses it. Running taskkill twice with
+ * a settle gap catches those late starters on the second pass — the second
+ * tree walk sees the child that was still being created during the first one.
+ * This is much cheaper than enumerating processes (wmic/PowerShell), which
+ * slows every kill down to seconds under parallel load.
+ */
+export function killTree(child) {
+    const pid = child.pid;
+    if (!pid)
+        return;
+    if (platform() === "win32") {
+        taskkillPid(pid);
+        sleepSync(150);
+        taskkillPid(pid);
+        return;
+    }
+    try {
+        process.kill(-pid, "SIGTERM");
+    }
+    catch {
+        try {
+            child.kill("SIGKILL");
+        }
+        catch {
+            /* already dead */
+        }
+    }
+}
+class ProcessRegistry {
+    procs = new Map();
+    children = new Map();
+    exitWaiters = new Map();
+    /**
+     * Start a command. The returned entry buffers output and reports status; a
+     * call may check `waitForExit(id)` to learn when (if ever) it finishes.
+     */
+    start(command, cwd, sessionId) {
+        const id = `proc_${Date.now()}_${++seq}`;
+        const entry = {
+            id,
+            pid: 0,
+            command,
+            cwd,
+            sessionId,
+            status: "running",
+            exitCode: null,
+            startedAt: new Date().toISOString(),
+            log: [],
+        };
+        this.trimOldEntries();
+        this.procs.set(id, entry);
+        let child;
+        try {
+            child = spawn(command, {
+                cwd,
+                shell: true,
+                windowsHide: true,
+                detached: platform() !== "win32",
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        }
+        catch (e) {
+            entry.status = "killed";
+            entry.spawnError = e?.message || String(e);
+            entry.log.push(`[process error] ${entry.spawnError}`);
+            return entry;
+        }
+        this.children.set(id, child);
+        entry.pid = child.pid ?? 0;
+        let buf = "";
+        let byteBuf = Buffer.alloc(0);
+        const isWin = platform() === "win32";
+        const unixDecoder = new TextDecoder("utf-8");
+        const pushLine = (line) => {
+            if (entry.log.length >= MAX_LOG_LINES) {
+                entry.log.shift();
+            }
+            entry.log.push(line);
+        };
+        const append = (chunk) => {
+            if (!isWin) {
+                const decoded = unixDecoder.decode(chunk, { stream: true });
+                buf += decoded;
+                const lines = buf.split(/\r?\n/);
+                buf = lines.pop() ?? "";
+                for (const line of lines) {
+                    pushLine(line);
+                }
+                return;
+            }
+            // Windows: buffer raw bytes and decode per line. Modern tools (Bun, Node,
+            // npm, git) write UTF-8 into the pipe regardless of the console code
+            // page; cmd.exe builtins (echo, type, dir) emit the OEM code page. Pick
+            // the right decoding per line so Russian text survives either way.
+            byteBuf = byteBuf.length ? Buffer.concat([byteBuf, chunk]) : Buffer.from(chunk);
+            let nl;
+            while ((nl = byteBuf.indexOf(0x0a)) !== -1) {
+                const raw = byteBuf.subarray(0, nl);
+                byteBuf = byteBuf.subarray(nl + 1);
+                pushLine(decodeLineToUtf8(raw).replace(/\r$/, ""));
+            }
+        };
+        const flush = () => {
+            if (!isWin) {
+                buf += unixDecoder.decode();
+                if (buf) {
+                    pushLine(buf);
+                    buf = "";
+                }
+                return;
+            }
+            if (byteBuf.length) {
+                pushLine(decodeLineToUtf8(byteBuf));
+                byteBuf = Buffer.alloc(0);
+            }
+        };
+        const resolveExit = () => {
+            this.exitWaiters.get(id)?.resolve();
+        };
+        child.stdout?.on("data", append);
+        child.stderr?.on("data", append);
+        child.on("error", (err) => {
+            if (entry.status === "running") {
+                entry.status = "killed";
+            }
+            entry.spawnError = err.message;
+            // Write directly to the log, not through `append`: a failed spawn often
+            // never emits `close`, so the buffered line would never be flushed and
+            // the log would be empty (observed: "records a spawn error" test).
+            pushLine(`[process error] ${err.message}`);
+            resolveExit();
+        });
+        child.on("close", (code) => {
+            flush();
+            if (entry.status === "running") {
+                entry.status = "exited";
+            }
+            entry.exitCode = code;
+            this.children.delete(id);
+            resolveExit();
+        });
+        let resolve;
+        const promise = new Promise((r) => {
+            resolve = r;
+        });
+        this.exitWaiters.set(id, { promise, resolve });
+        return entry;
+    }
+    list(sessionId) {
+        const all = Array.from(this.procs.values());
+        if (!sessionId)
+            return all;
+        return all.filter((p) => p.sessionId === sessionId);
+    }
+    get(id) {
+        return this.procs.get(id);
+    }
+    getLog(id, tail) {
+        const entry = this.procs.get(id);
+        if (!entry)
+            return "";
+        const lines = tail && tail > 0 ? entry.log.slice(-tail) : entry.log;
+        return lines.join("\n");
+    }
+    /** Kill a background process tree. Returns false when not found. */
+    kill(id) {
+        const entry = this.procs.get(id);
+        if (!entry)
+            return false;
+        if (entry.status === "running") {
+            entry.status = "killed";
+            const child = this.children.get(id);
+            if (child) {
+                killTree(child);
+            }
+        }
+        return true;
+    }
+    /** Kill every managed background process (used on agent shutdown). */
+    killAll(sessionId) {
+        const targets = this.list(sessionId);
+        for (const entry of targets) {
+            this.kill(entry.id);
+        }
+        return targets.length;
+    }
+    /**
+     * Resolve `true` when the process exits (or fails to spawn) within
+     * `timeoutMs`, otherwise `false` (still running → a background process).
+     */
+    waitForExit(id, timeoutMs) {
+        const entry = this.procs.get(id);
+        const waiter = this.exitWaiters.get(id);
+        if (!entry || entry.status !== "running" || !waiter) {
+            return Promise.resolve(true);
+        }
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => resolve(false), timeoutMs);
+            waiter.promise.then(() => {
+                clearTimeout(timer);
+                resolve(true);
+            });
+        });
+    }
+    /**
+     * Remove a finished entry (foreground results do not linger). A still-running
+     * entry is killed first so nothing is orphaned.
+     */
+    remove(id) {
+        const entry = this.procs.get(id);
+        if (!entry)
+            return false;
+        if (entry.status === "running") {
+            const child = this.children.get(id);
+            if (child) {
+                killTree(child);
+            }
+            entry.status = "killed";
+        }
+        this.procs.delete(id);
+        this.children.delete(id);
+        this.exitWaiters.delete(id);
+        return true;
+    }
+    trimOldEntries() {
+        if (this.procs.size < MAX_KEPT_PROCESSES)
+            return;
+        const sorted = Array.from(this.procs.values()).sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+        const toRemove = sorted.slice(0, sorted.length - MAX_KEPT_PROCESSES + 1);
+        for (const entry of toRemove) {
+            this.remove(entry.id);
+        }
+    }
+}
+export const processRegistry = new ProcessRegistry();

package/dist/modules/processes/runner.js

@@ -0,0 +1,23 @@
+const activeChildren = new Map();
+/** Register a kill callback for a tool call id (executor timeout/abort). */
+export function registerKillable(callId, kill) {
+    activeChildren.set(callId, { kill });
+}
+/** Unregister a tool call's kill callback once its handler finished. */
+export function unregisterKillable(callId) {
+    activeChildren.delete(callId);
+}
+/** Invoke (and drop) the kill callback registered for `callId`. */
+export function killByCallId(callId) {
+    const entry = activeChildren.get(callId);
+    if (!entry)
+        return false;
+    activeChildren.delete(callId);
+    try {
+        entry.kill();
+    }
+    catch {
+        /* already dead */
+    }
+    return true;
+}

package/dist/modules/providers/create.js

@@ -0,0 +1,22 @@
+import { BUILTIN_PROVIDERS } from "./presets";
+import { ProviderRegistry as Registry } from "./registry";
+/**
+ * The single entry point for building a provider. Unknown types fall back to
+ * the OpenAI-compatible provider (backward compatible with legacy configs that
+ * use a custom `type` + baseUrl).
+ */
+export function createProvider(type, opts, registry = defaultRegistry()) {
+    const spec = registry.get(type);
+    if (!spec) {
+        return BUILTIN_PROVIDERS[0].create(opts);
+    }
+    return spec.create(opts);
+}
+/** Registry preloaded with all builtin provider presets. */
+export function defaultRegistry() {
+    const registry = new Registry();
+    for (const spec of BUILTIN_PROVIDERS) {
+        registry.register(spec);
+    }
+    return registry;
+}

package/dist/modules/providers/fallback.js

@@ -0,0 +1,79 @@
+/** True when the error is worth failing over to another provider. */
+export function isFailoverError(err) {
+    const e = err;
+    if (e?.name === "AbortError")
+        return false;
+    // HTTP status attached by openai-compat: retryable statuses only.
+    if (typeof e?.llmStatus === "number")
+        return e.llmStatus === 429 || e.llmStatus >= 500;
+    // Network-level failures by errno-style code (Bun: "ConnectionRefused",
+    // Node: "ECONNREFUSED", DNS: "ENOTFOUND"/"EAI_AGAIN", etc).
+    const normCode = (e?.code ?? "").replace(/[-_]/g, "").toLowerCase();
+    if (/^abort/.test(normCode))
+        return false;
+    if (/conn(refused|reset|timedout)|enotfound|eai_again|namenotresolved/.test(normCode)) {
+        return true;
+    }
+    // Network-level failures by message (fetch failed, timeouts, socket resets).
+    return /fetch failed|unable to connect|network|econnrefused|enotfound|etimedout|socket hang up|connection refused|connection reset/i.test(e?.message ?? "");
+}
+/**
+ * Wraps a FallbackSource so that retryable failures (429/5xx/network) on the
+ * active provider transparently switch to the next configured entry and retry
+ * there. Failover happens ONLY before any chunk was emitted — mid-stream
+ * failures rethrow to avoid duplicated output. The last provider that served
+ * a successful call becomes the new active entry (sticky).
+ */
+export class FallbackProvider {
+    source;
+    onFailover;
+    constructor(source, onFailover) {
+        this.source = source;
+        this.onFailover = onFailover;
+    }
+    get model() {
+        return this.source.active.model;
+    }
+    get contextWindow() {
+        return this.source.active.contextWindow;
+    }
+    async *chat(messages, tools, signal, options) {
+        const names = this.source.listNames();
+        if (names.length <= 1) {
+            yield* this.source.active.chat(messages, tools, signal, options);
+            return;
+        }
+        let emitted = false;
+        let idx = Math.max(0, names.indexOf(this.source.activeName));
+        let lastError;
+        for (let attempt = 0; attempt < names.length; attempt++) {
+            const name = names[idx];
+            const provider = name === this.source.activeName
+                ? this.source.active
+                : this.source.switch(name);
+            try {
+                for await (const chunk of provider.chat(messages, tools, signal, options)) {
+                    emitted = true;
+                    yield chunk;
+                }
+                return;
+            }
+            catch (err) {
+                // Mid-stream failure after content was delivered: a restart would
+                // duplicate chunks — surface the error instead of failing over.
+                if (emitted || !isFailoverError(err))
+                    throw err;
+                lastError = err;
+                idx = (idx + 1) % names.length;
+                this.onFailover?.(name, names[idx], err);
+            }
+        }
+        throw lastError;
+    }
+    countTokens(text) {
+        return this.source.active.countTokens(text);
+    }
+    async listModels() {
+        return this.source.active.listModels();
+    }
+}

package/dist/modules/providers/health.js

@@ -0,0 +1,46 @@
+/**
+ * Probe providers concurrently (bounded by the caller passing few entries)
+ * and report ✓/✗ per entry. Uses `listModels()` — a free, cheap call — never
+ * a billed chat completion. Input order is preserved in the output.
+ */
+export async function probeProviders(targets, opts) {
+    const timeoutMs = opts?.timeoutMs ?? 5000;
+    const results = await Promise.all(targets.map((t) => probeOne(t, timeoutMs)));
+    return results;
+}
+async function probeOne(target, timeoutMs) {
+    const start = Date.now();
+    try {
+        const models = await withTimeout(target.listModels(), timeoutMs);
+        return { name: target.name, ok: true, ms: Date.now() - start, models: models.length };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            name: target.name,
+            ok: false,
+            ms: Date.now() - start,
+            models: 0,
+            error: message,
+        };
+    }
+}
+function withTimeout(promise, ms) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`timeout after ${ms}ms`)), ms);
+        promise.then((v) => {
+            clearTimeout(timer);
+            resolve(v);
+        }, (e) => {
+            clearTimeout(timer);
+            reject(e);
+        });
+    });
+}
+/** Build probe targets from a name→provider mapping (priority order). */
+export function targetsFromProviders(entries) {
+    return entries.map(({ name, provider }) => ({
+        name,
+        listModels: () => provider.listModels(),
+    }));
+}

package/dist/modules/providers/index.js

@@ -0,0 +1,5 @@
+export { ProviderRegistry } from "./registry";
+export { createProvider, defaultRegistry } from "./create";
+export { ProviderManager, presetOf } from "./manager";
+export { probeProviders, targetsFromProviders, } from "./health";
+export { BUILTIN_PROVIDERS, HOSTED_BASE_URLS } from "./presets";

package/dist/modules/providers/manager.js

@@ -0,0 +1,161 @@
+import { createProvider, defaultRegistry } from "./create";
+import { BUILTIN_PROVIDERS } from "./presets";
+/**
+ * Manages the active provider + model at runtime. Supports several configured
+ * providers (`ProviderConfig.entries`) with hot-swap (`switch`, `setModel`).
+ * Legacy single-provider configs (`{type, baseUrl, apiKey}`) are normalized
+ * into a single-entry list, so existing configs keep working.
+ */
+export class ProviderManager {
+    entries;
+    activeProviderName;
+    model;
+    opts;
+    registry;
+    cache = new Map();
+    constructor(config, opts) {
+        this.opts = opts;
+        this.registry = opts.registry ?? defaultRegistry();
+        this.entries = this.normalizeEntries(config);
+        this.activeProviderName = this.resolveActive(config);
+        this.model = "";
+    }
+    /** The model the active provider is built with. */
+    get activeModel() {
+        return this.model;
+    }
+    /** Name/label of the active provider. */
+    get activeName() {
+        return this.activeProviderName;
+    }
+    get active() {
+        return this.build(this.activeProviderName);
+    }
+    get activeEntry() {
+        const entry = this.entryByName(this.activeProviderName);
+        if (!entry)
+            throw new Error(`Unknown active provider "${this.activeProviderName}"`);
+        return entry;
+    }
+    /** All configured entries (resolved with preset metadata), priority-ordered. */
+    list() {
+        return this.entries
+            .map((e) => {
+            const preset = this.registry.get(e.type);
+            return { ...e, label: e.label || preset?.label || e.type };
+        })
+            .map((e, i) => ({ e, i, p: e.priority ?? Number.MAX_SAFE_INTEGER }))
+            .sort((a, b) => a.p - b.p || a.i - b.i)
+            .map(({ e }) => e);
+    }
+    listNames() {
+        return this.list().map((e) => e.label);
+    }
+    /**
+     * CODE-ONLY capability routing (Phase 4.4): pick the first entry (priority
+     * order) whose preset capabilities and context window satisfy `needs`.
+     * Never exposed to the LLM — the model must not choose providers.
+     */
+    pickFor(needs) {
+        const globalWindow = this.opts.contextWindow;
+        // No constraints → keep the current active provider.
+        if (!needs.vision && !needs.tools && needs.minContext === undefined) {
+            return this.activeProviderName;
+        }
+        for (const e of this.list()) {
+            const caps = this.registry.get(e.type)?.capabilities;
+            if (needs.vision && !caps?.vision)
+                continue;
+            if (needs.tools && !caps?.tools)
+                continue;
+            if (needs.minContext !== undefined &&
+                (e.contextWindow ?? globalWindow) < needs.minContext) {
+                continue;
+            }
+            return e.label;
+        }
+        return undefined;
+    }
+    /** Hot-swap to a named provider; rebuild the active provider. */
+    switch(name, model) {
+        if (!this.entryByName(name)) {
+            throw new Error(`Unknown provider "${name}"`);
+        }
+        this.activeProviderName = name;
+        if (model !== undefined)
+            this.model = model;
+        return this.active;
+    }
+    /** Rebuild the active provider with a new model. */
+    setModel(model) {
+        this.model = model;
+        return this.active;
+    }
+    /** Serialize back to ProviderConfig (keeps active/entries in sync). */
+    toConfig() {
+        const active = this.activeEntry;
+        return {
+            active: this.activeProviderName,
+            entries: this.entries,
+            fallback: false,
+            type: active.type,
+            baseUrl: active.baseUrl,
+            apiKey: active.apiKey,
+        };
+    }
+    normalizeEntries(config) {
+        if (Array.isArray(config.entries) && config.entries.length > 0) {
+            return config.entries.map((e) => ({ ...e, label: e.label || e.type }));
+        }
+        // Legacy single-provider form (or empty config) → one default entry.
+        return [
+            {
+                type: config.type ?? "openai-compat",
+                label: config.type ?? "openai-compat",
+                baseUrl: config.baseUrl ?? "",
+                apiKey: config.apiKey,
+                maxCompletionTokens: config.maxCompletionTokens,
+            },
+        ];
+    }
+    resolveActive(config) {
+        if (config.active && this.entryByName(config.active))
+            return config.active;
+        const first = this.entries[0];
+        return first ? (first.label ?? "openai-compat") : "openai-compat";
+    }
+    entryByName(name) {
+        return this.entries.find((e) => e.label === name || e.type === name);
+    }
+    build(name) {
+        const entry = this.entryByName(name);
+        if (!entry)
+            throw new Error(`Unknown provider "${name}"`);
+        const key = `${name}|${this.model}`;
+        const cached = this.cache.get(key);
+        if (cached)
+            return cached;
+        const provider = createProvider(entry.type, {
+            model: this.model,
+            baseUrl: entry.baseUrl,
+            apiKey: entry.apiKey,
+            contextWindow: entry.contextWindow ?? this.opts.contextWindow,
+            retry: entry.retry ?? this.opts.retry,
+            rateLimits: entry.rateLimits ?? this.opts.rateLimits,
+            maxCompletionTokens: entry.maxCompletionTokens,
+        }, this.registry);
+        this.cache.set(key, provider);
+        return provider;
+    }
+    /** Clear the build cache (on config change). */
+    resetCache() {
+        this.cache.clear();
+    }
+}
+/** Export preset metadata for the CLI (label/capabilities/baseUrl). */
+export function presetOf(type) {
+    const spec = BUILTIN_PROVIDERS.find((p) => p.type === type);
+    if (!spec)
+        return undefined;
+    return { label: spec.label, baseUrl: spec.baseUrl };
+}