micro-models-agent 0.57.0 → 0.57.1

package/dist/modules/plugins/manager.js

@@ -0,0 +1,261 @@
+import { semverGt } from "../updater/checker";
+export class PluginManager {
+    plugins = [];
+    hostBridge = null;
+    /**
+     * Register the host bridge (set once by the REPL). It is merged into every
+     * hook context as `ctx.hostBridge` unless the caller already provided one.
+     */
+    setHostBridge(bridge) {
+        this.hostBridge = bridge;
+    }
+    /** Merge the host bridge into a hook context (caller-provided value wins). */
+    withHost(ctx) {
+        if (!ctx || typeof ctx !== "object")
+            return ctx;
+        if (!this.hostBridge || ctx.hostBridge !== undefined) {
+            return ctx;
+        }
+        return { ...ctx, hostBridge: this.hostBridge };
+    }
+    /**
+     * Register a plugin. Plugins with the same `name` are deduplicated — the
+     * higher `version` wins (unversioned plugins count as "0.0.0"). The loser is
+     * discarded; `skipped_older` lets the caller warn about the dropped copy.
+     */
+    register(plugin, source) {
+        if (source)
+            plugin.source = source;
+        const existing = this.plugins.find((p) => p.name === plugin.name);
+        if (existing) {
+            if (semverGt(plugin.version || "0.0.0", existing.version || "0.0.0")) {
+                this.plugins = this.plugins.filter((p) => p.name !== plugin.name);
+                this.plugins.push(plugin);
+                this.sort();
+                return { status: "registered" };
+            }
+            return { status: "skipped_older", existing };
+        }
+        this.plugins.push(plugin);
+        this.sort();
+        return { status: "registered" };
+    }
+    sort() {
+        this.plugins.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+    }
+    getAllPlugins() {
+        return [...this.plugins];
+    }
+    /** Detailed plugin list (name, version, source) for REPL / CLI display. */
+    getPluginInfos() {
+        return [...this.plugins].map((plugin) => ({ plugin, source: plugin.source }));
+    }
+    /** Find a registered plugin by name, or null. */
+    getPlugin(name) {
+        return this.plugins.find((p) => p.name === name) ?? null;
+    }
+    runOnBuildPrompt() {
+        return this.plugins.map((p) => {
+            try {
+                return p.onBuildPrompt?.() ?? null;
+            }
+            catch {
+                return null;
+            }
+        });
+    }
+    async runOnBeforeTool(rawCtx, call) {
+        const ctx = this.withHost(rawCtx);
+        for (const plugin of this.plugins) {
+            if (plugin.onBeforeTool) {
+                try {
+                    const result = await plugin.onBeforeTool(ctx, call);
+                    if (result === false)
+                        return false;
+                }
+                catch {
+                    /* error isolation */
+                }
+            }
+        }
+        return true;
+    }
+    async runOnAfterTool(rawCtx, call, result) {
+        const ctx = this.withHost(rawCtx);
+        for (const plugin of this.plugins) {
+            if (plugin.onAfterTool) {
+                try {
+                    await plugin.onAfterTool(ctx, call, result);
+                }
+                catch {
+                    /* error isolation */
+                }
+            }
+        }
+    }
+    async runOnError(rawCtx, error) {
+        const ctx = this.withHost(rawCtx);
+        for (const plugin of this.plugins) {
+            if (plugin.onError) {
+                try {
+                    await plugin.onError(ctx, error);
+                }
+                catch {
+                    /* error isolation */
+                }
+            }
+        }
+    }
+    runOnSessionStart(rawCtx) {
+        const ctx = this.withHost(rawCtx);
+        for (const plugin of this.plugins) {
+            if (plugin.onSessionStart) {
+                try {
+                    plugin.onSessionStart(ctx);
+                }
+                catch {
+                    /* error isolation */
+                }
+            }
+        }
+    }
+    runOnBeforeThink(rawCtx) {
+        const ctx = this.withHost(rawCtx);
+        for (const plugin of this.plugins) {
+            if (plugin.onBeforeThink) {
+                try {
+                    plugin.onBeforeThink(ctx);
+                }
+                catch {
+                    /* error isolation */
+                }
+            }
+        }
+    }
+    runOnAfterThink(rawCtx, response) {
+        const ctx = this.withHost(rawCtx);
+        for (const plugin of this.plugins) {
+            if (plugin.onAfterThink) {
+                try {
+                    plugin.onAfterThink(ctx, response);
+                }
+                catch {
+                    /* error isolation */
+                }
+            }
+        }
+    }
+    runOnSessionEnd(rawCtx) {
+        const ctx = this.withHost(rawCtx);
+        for (const plugin of this.plugins) {
+            if (plugin.onSessionEnd) {
+                try {
+                    plugin.onSessionEnd(ctx);
+                }
+                catch {
+                    /* error isolation */
+                }
+            }
+        }
+    }
+    runOnToolCall(rawCtx) {
+        const ctx = this.withHost(rawCtx);
+        for (const plugin of this.plugins) {
+            if (plugin.onToolCall) {
+                try {
+                    plugin.onToolCall(ctx);
+                }
+                catch {
+                    /* error isolation */
+                }
+            }
+        }
+    }
+    runOnPhase(rawCtx, phase) {
+        const ctx = this.withHost(rawCtx);
+        for (const plugin of this.plugins) {
+            if (plugin.onPhase) {
+                try {
+                    plugin.onPhase(ctx, phase);
+                }
+                catch {
+                    /* error isolation */
+                }
+            }
+        }
+    }
+    runOnToolStart(rawCtx, call) {
+        const ctx = this.withHost(rawCtx);
+        for (const plugin of this.plugins) {
+            if (plugin.onToolStart) {
+                try {
+                    plugin.onToolStart(ctx, call);
+                }
+                catch {
+                    /* error isolation */
+                }
+            }
+        }
+    }
+    runOnToolEnd(rawCtx, call, result, durationMs) {
+        const ctx = this.withHost(rawCtx);
+        for (const plugin of this.plugins) {
+            if (plugin.onToolEnd) {
+                try {
+                    plugin.onToolEnd(ctx, call, result, durationMs);
+                }
+                catch {
+                    /* error isolation */
+                }
+            }
+        }
+    }
+    /** Pipe a text chunk through plugin transforms; returns the (possibly replaced) chunk. */
+    runOnText(rawCtx, chunk) {
+        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 */
+                }
+            }
+        }
+        return chunk;
+    }
+    /** Pipe a meta chunk through plugin transforms; returns the (possibly replaced) chunk. */
+    runOnMeta(rawCtx, chunk) {
+        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 */
+                }
+            }
+        }
+        return chunk;
+    }
+    /** Dispatch a completed-run summary to all plugins (once per Agent.run()). */
+    runOnTurnEnd(rawCtx, summary) {
+        const ctx = this.withHost(rawCtx);
+        for (const plugin of this.plugins) {
+            if (plugin.onTurnEnd) {
+                try {
+                    plugin.onTurnEnd(ctx, summary);
+                }
+                catch {
+                    /* error isolation */
+                }
+            }
+        }
+    }
+}

package/dist/modules/plugins/types.js

@@ -0,0 +1 @@
+export {};

package/dist/modules/pricing/index.js

@@ -0,0 +1,61 @@
+import { calculateCost, 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
+ * (estimated or API) token usage and the provider name; read `total` for the
+ * running total, `totalFor(provider)` / `breakdown()` for per-provider
+ * attribution. When the model has no known price, `record` is a no-op.
+ */
+export class CostTracker {
+    config;
+    model;
+    _total = 0;
+    _known = false;
+    byProvider = new Map();
+    constructor(model, config) {
+        this.model = model;
+        this.config = config;
+    }
+    /** Update the model (on /model switch). Later records use the new price. */
+    setModel(model) {
+        this.model = model;
+    }
+    /** Record a single LLM call's token usage, attributed to `provider`. */
+    record(promptTokens, completionTokens, provider) {
+        const key = provider || "unknown";
+        const cost = calculateCost(this.model, promptTokens, completionTokens, this.config);
+        if (cost === undefined)
+            return;
+        this._known = true;
+        this._total += cost;
+        let entry = this.byProvider.get(key);
+        if (!entry) {
+            entry = { total: 0, known: false };
+            this.byProvider.set(key, entry);
+        }
+        entry.known = true;
+        entry.total += cost;
+    }
+    /** Running total cost in USD, or undefined if no model price is known. */
+    get total() {
+        return this._known ? this._total : undefined;
+    }
+    /** Total for one provider, or undefined when nothing was priced for it. */
+    totalFor(provider) {
+        const entry = this.byProvider.get(provider);
+        return entry && entry.known ? entry.total : undefined;
+    }
+    /** Per-provider totals sorted by cost descending (priced providers only). */
+    breakdown() {
+        const entries = [];
+        for (const [provider, entry] of this.byProvider) {
+            if (entry.known)
+                entries.push({ provider, cost: entry.total });
+        }
+        return entries.sort((a, b) => b.cost - a.cost);
+    }
+    /** Human-readable total, or undefined when pricing is unavailable. */
+    get formatted() {
+        return this._known ? formatCost(this._total) : undefined;
+    }
+}

package/dist/modules/pricing/prices.js

@@ -0,0 +1,129 @@
+/**
+ * Built-in price table (USD per 1M tokens) for OpenCode Zen / Go models.
+ * Values from https://opencode.ai/docs/zen/ and /docs/go/ (August 2026).
+ * Model ids are stored WITHOUT the `opencode/` or `opencode-go/` prefix so a
+ * single table serves both providers; lookup strips the prefix.
+ */
+const ZEN_PRICES = {
+    // Free models
+    "big-pickle": { input: 0, output: 0 },
+    "mimo-v2.5-free": { input: 0, output: 0 },
+    "hy3-free": { input: 0, output: 0 },
+    "nemotron-3-ultra-free": { input: 0, output: 0 },
+    "nemotron-3.5-lightning-free": { input: 0, output: 0 },
+    "muse-spark-1.2-contributor-free": { input: 0, output: 0 },
+    // MiniMax
+    "minimax-m3": { input: 0.3, output: 1.2 },
+    "minimax-m2.7": { input: 0.3, output: 1.2 },
+    "minimax-m2.5": { input: 0.3, output: 1.2 },
+    // GLM
+    "glm-5.2": { input: 1.4, output: 4.4 },
+    "glm-5.1": { input: 1.4, output: 4.4 },
+    "glm-5": { input: 1.0, output: 3.2 },
+    "glm-5.3": { input: 1.4, output: 4.4 },
+    // Kimi
+    "kimi-k2.7-code": { input: 0.95, output: 4.0 },
+    "kimi-k3": { input: 3.0, output: 15.0 },
+    "kimi-k2.6": { input: 0.95, output: 4.0 },
+    "kimi-k2.5": { input: 0.6, output: 3.0 },
+    // Qwen
+    "qwen3.7-max": { input: 2.5, output: 7.5 },
+    "qwen3.7-plus": { input: 0.4, output: 1.6 },
+    "qwen3.6-plus": { input: 0.5, output: 3.0 },
+    "qwen3.5-plus": { input: 0.2, output: 1.2 },
+    "qwen3.8-max": { input: 2.5, output: 7.5 },
+    // DeepSeek (off-peak)
+    "deepseek-v4-pro": { input: 0.66, output: 1.98 },
+    "deepseek-v4-flash": { input: 0.22, output: 0.66 },
+    // Claude
+    "claude-fable-5": { input: 10, output: 50 },
+    "claude-opus-5": { input: 5, output: 25 },
+    "claude-opus-4-8": { input: 5, output: 25 },
+    "claude-opus-4-7": { input: 5, output: 25 },
+    "claude-opus-4-6": { input: 5, output: 25 },
+    "claude-opus-4-5": { input: 5, output: 25 },
+    "claude-sonnet-5": { input: 2, output: 10 },
+    "claude-sonnet-4-6": { input: 3, output: 15 },
+    "claude-sonnet-4-5": { input: 3, output: 15 },
+    "claude-haiku-4-5": { input: 1, output: 5 },
+    // Gemini
+    "gemini-3.7-flash": { input: 1.5, output: 7.5 },
+    "gemini-3.6-flash": { input: 1.5, output: 7.5 },
+    "gemini-3.5-flash": { input: 1.5, output: 9.0 },
+    "gemini-3.5-flash-lite": { input: 0.3, output: 2.5 },
+    "gemini-3.1-pro": { input: 2, output: 12 },
+    "gemini-3-flash": { input: 0.5, output: 3.0 },
+    // Grok
+    "grok-4.6": { input: 2, output: 6 },
+    "grok-4.5": { input: 2, output: 6 },
+    "grok-build-0.1": { input: 1, output: 2 },
+    // Muse Spark
+    "muse-spark-1.2": { input: 1.25, output: 4.25 },
+    // GPT-5.x (Zen pricing; Go may differ)
+    "gpt-5.6-sol": { input: 5, output: 30 },
+    "gpt-5.6-terra": { input: 2, output: 12 },
+    "gpt-5.6-luna": { input: 0.2, output: 1.2 },
+    "gpt-5.5": { input: 5, output: 30 },
+    "gpt-5.5-pro": { input: 30, output: 180 },
+    "gpt-5.4": { input: 2.5, output: 15 },
+    "gpt-5.4-pro": { input: 30, output: 180 },
+    "gpt-5.4-mini": { input: 0.75, output: 4.5 },
+    "gpt-5.4-nano": { input: 0.2, output: 1.25 },
+    "gpt-5.3-codex": { input: 1.75, output: 14 },
+    "gpt-5.3-codex-spark": { input: 1.75, output: 14 },
+    "gpt-5.2": { input: 1.75, output: 14 },
+    "gpt-5.2-codex": { input: 1.75, output: 14 },
+    "gpt-5.1": { input: 1.07, output: 8.5 },
+    "gpt-5.1-codex": { input: 1.07, output: 8.5 },
+    "gpt-5.1-codex-max": { input: 1.25, output: 10 },
+    "gpt-5.1-codex-mini": { input: 0.25, output: 2 },
+    "gpt-5": { input: 1.07, output: 8.5 },
+    "gpt-5-codex": { input: 1.07, output: 8.5 },
+    "gpt-5-nano": { input: 0.05, output: 0.4 },
+};
+/** Provider prefixes stripped before a price lookup. */
+const PROVIDER_PREFIXES = ["opencode-go/", "opencode/", "openai/", "anthropic/"];
+/** Normalize a model id to its bare form for the price table lookup. */
+export function normalizeModelId(model) {
+    let id = model.trim();
+    for (const prefix of PROVIDER_PREFIXES) {
+        if (id.startsWith(prefix)) {
+            id = id.slice(prefix.length);
+            break;
+        }
+    }
+    // Strip a vendor path like qwen/qwen3.5-9b -> qwen3.5-9b (keeps bare ids).
+    const parts = id.split("/");
+    return parts[parts.length - 1];
+}
+/** Resolve the price for a model id. Overrides win, then the builtin table. */
+export function resolvePrice(model, config) {
+    if (!config?.enabled)
+        return undefined;
+    const bare = normalizeModelId(model);
+    const overrides = config.overrides ?? {};
+    const direct = overrides[model] ?? overrides[bare];
+    if (direct)
+        return direct;
+    return ZEN_PRICES[bare];
+}
+/**
+ * Compute the cost in USD of a single call given its token usage and the
+ * model price. Returns undefined when the model has no known price.
+ */
+export function calculateCost(model, promptTokens, completionTokens, config) {
+    const price = resolvePrice(model, config);
+    if (!price)
+        return undefined;
+    return (promptTokens / 1_000_000) * price.input + (completionTokens / 1_000_000) * price.output;
+}
+/** Format a USD cost for display. Zero and very small amounts stay readable. */
+export function formatCost(cost) {
+    if (cost === 0)
+        return "$0.00";
+    if (cost >= 0.01)
+        return `$${cost.toFixed(2)}`;
+    if (cost >= 0.0001)
+        return `$${cost.toFixed(4)}`;
+    return `$${cost.toFixed(6)}`;
+}

package/dist/modules/processes/detect.js

@@ -0,0 +1,34 @@
+/**
+ * Heuristic detection of long-running (server/watch) commands.
+ *
+ * The explicit `background: true` bash parameter always wins; this list is a
+ * convenience so dev servers don't block the agent. It only inspects the raw
+ * shell command (a technical process-type decision, not task classification).
+ */
+const LONG_RUNNING_PATTERNS = [
+    /\b(npm|pnpm|yarn|bun|npx)\s+(run\s+)?(dev|start|serve|preview|watch|server)\b/i,
+    /\b(deno|node)\s+.*\b(run\s+)?(dev|serve|watch|server)\b/i,
+    /(^|\s)--watch\b/i,
+    /(^|\s)-w\b/i,
+    /\bnodemon\b/i,
+    /\btsx watch\b/i,
+    /\b(ts-node|tsc)\s+.*--watch\b/i,
+    /\bvite(?!\s+(build|create))\b/i,
+    /\bwebpack(-dev-server|\s+serve)\b/i,
+    /\bastro dev\b/i,
+    /\bnext (dev|start)\b/i,
+    /\bnuxt (dev|start)\b/i,
+    /\bsvelte-kit (dev|preview)\b/i,
+    /\bgatsby develop\b/i,
+    /\bdocker(-compose)?\s+.*\bup\b/i,
+    /\buvicorn\b|\bgunicorn\b/i,
+    /\bpython\s+-m\s+http\.server\b/i,
+    /\bflask run\b/i,
+    /\bphp artisan serve\b/i,
+    /\brails (server|s)\b/i,
+    /\bvitest watch\b/i,
+    /\bjest --watch\b/i,
+];
+export function isLongRunningCommand(command) {
+    return LONG_RUNNING_PATTERNS.some((pattern) => pattern.test(command));
+}

package/dist/modules/processes/index.js

@@ -0,0 +1,2 @@
+export { registerKillable, unregisterKillable, killByCallId } from "./runner";
+export { processRegistry } from "./registry";