micro-models-agent 0.51.1 → 0.52.0

package/dist/modules/plugins/manager.js

@@ -1,6 +1,23 @@
 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
@@ -47,7 +64,8 @@ export class PluginManager {
             }
         });
     }
-    async runOnBeforeTool(ctx, call) {
+    async runOnBeforeTool(rawCtx, call) {
+        const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onBeforeTool) {
                 try {
@@ -62,7 +80,8 @@ export class PluginManager {
         }
         return true;
     }
-    async runOnAfterTool(ctx, call, result) {
+    async runOnAfterTool(rawCtx, call, result) {
+        const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onAfterTool) {
                 try {
@@ -74,7 +93,8 @@ export class PluginManager {
             }
         }
     }
-    async runOnError(ctx, error) {
+    async runOnError(rawCtx, error) {
+        const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onError) {
                 try {
@@ -86,7 +106,8 @@ export class PluginManager {
             }
         }
     }
-    runOnSessionStart(ctx) {
+    runOnSessionStart(rawCtx) {
+        const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onSessionStart) {
                 try {
@@ -98,7 +119,8 @@ export class PluginManager {
             }
         }
     }
-    runOnBeforeThink(ctx) {
+    runOnBeforeThink(rawCtx) {
+        const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onBeforeThink) {
                 try {
@@ -110,7 +132,8 @@ export class PluginManager {
             }
         }
     }
-    runOnAfterThink(ctx, response) {
+    runOnAfterThink(rawCtx, response) {
+        const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onAfterThink) {
                 try {
@@ -122,7 +145,8 @@ export class PluginManager {
             }
         }
     }
-    runOnSessionEnd(ctx) {
+    runOnSessionEnd(rawCtx) {
+        const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onSessionEnd) {
                 try {
@@ -134,7 +158,8 @@ export class PluginManager {
             }
         }
     }
-    runOnToolCall(ctx) {
+    runOnToolCall(rawCtx) {
+        const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onToolCall) {
                 try {
@@ -146,7 +171,8 @@ export class PluginManager {
             }
         }
     }
-    runOnPhase(ctx, phase) {
+    runOnPhase(rawCtx, phase) {
+        const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onPhase) {
                 try {
@@ -158,7 +184,8 @@ export class PluginManager {
             }
         }
     }
-    runOnToolStart(ctx, call) {
+    runOnToolStart(rawCtx, call) {
+        const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onToolStart) {
                 try {
@@ -170,7 +197,8 @@ export class PluginManager {
             }
         }
     }
-    runOnToolEnd(ctx, call, result, durationMs) {
+    runOnToolEnd(rawCtx, call, result, durationMs) {
+        const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onToolEnd) {
                 try {
@@ -183,7 +211,8 @@ export class PluginManager {
         }
     }
     /** Pipe a text chunk through plugin transforms; returns the (possibly replaced) chunk. */
-    runOnText(ctx, chunk) {
+    runOnText(rawCtx, chunk) {
+        const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onText) {
                 try {
@@ -199,7 +228,8 @@ export class PluginManager {
         return chunk;
     }
     /** Pipe a meta chunk through plugin transforms; returns the (possibly replaced) chunk. */
-    runOnMeta(ctx, chunk) {
+    runOnMeta(rawCtx, chunk) {
+        const ctx = this.withHost(rawCtx);
         for (const plugin of this.plugins) {
             if (plugin.onMeta) {
                 try {
@@ -214,4 +244,18 @@ export class PluginManager {
         }
         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/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/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 };
+}