@elizaos/ui 2.0.0-alpha.85 → 2.0.0-beta.2

package/services/local-inference/engine.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Standalone llama.cpp engine.
+ *
+ * Owns one `Llama` binding instance, at most one loaded `LlamaModel`, and
+ * a cached `LlamaChatSession` that wraps it. Model swap is unload-then-load
+ * so we never double-allocate VRAM.
+ *
+ * Two consumption paths:
+ *   1. The Model Hub UI calls `load()` / `unload()` to make "Activate" work.
+ *   2. The agent runtime calls `generate()` via the registered
+ *      `ModelType.TEXT_SMALL` / `TEXT_LARGE` handlers (see
+ *      `ensure-local-inference-handler.ts`).
+ *
+ * Dynamic import keeps the binding optional: if `node-llama-cpp` is not
+ * installed, `available()` returns false and callers surface a clear error
+ * instead of crashing the process.
+ */
+import type { LocalInferenceLoadArgs } from "./active-model";
+export interface GenerateArgs {
+    prompt: string;
+    stopSequences?: string[];
+    /** Upper bound on output tokens; defaults to 2048. */
+    maxTokens?: number;
+    /** 0..1; 0.7 default. */
+    temperature?: number;
+    /** nucleus sampling; defaults to 0.9. */
+    topP?: number;
+}
+export declare class LocalInferenceEngine {
+    private llama;
+    private loadedModel;
+    private loadedContext;
+    private loadedSession;
+    private loadedPath;
+    private bindingChecked;
+    private bindingModule;
+    /** Serialises generate calls so concurrent requests don't corrupt session state. */
+    private generationQueue;
+    available(): Promise<boolean>;
+    currentModelPath(): string | null;
+    hasLoadedModel(): boolean;
+    unload(): Promise<void>;
+    load(modelPath: string, resolved?: LocalInferenceLoadArgs): Promise<void>;
+    /**
+     * Generate text from the loaded model. Serialised — a new call waits for
+     * any in-flight generation to finish so the chat session's internal state
+     * stays consistent.
+     */
+    generate(args: GenerateArgs): Promise<string>;
+    private loadBinding;
+    private resolveDflashPlan;
+}
+export declare const localInferenceEngine: LocalInferenceEngine;
+//# sourceMappingURL=engine.d.ts.map

package/services/local-inference/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../../../../src/services/local-inference/engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAgB7D,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yBAAyB;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,yCAAyC;IACzC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AA4DD,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,WAAW,CAA2B;IAC9C,OAAO,CAAC,aAAa,CAA6B;IAClD,OAAO,CAAC,aAAa,CAAiC;IACtD,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,aAAa,CAAmC;IACxD,oFAAoF;IACpF,OAAO,CAAC,eAAe,CAAuC;IAExD,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;IAQnC,gBAAgB,IAAI,MAAM,GAAG,IAAI;IAOjC,cAAc,IAAI,OAAO;IAInB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAyBvB,IAAI,CACR,SAAS,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,sBAAsB,GAChC,OAAO,CAAC,IAAI,CAAC;IA6DhB;;;;OAIG;IACG,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;YA6BrC,WAAW;YAoBX,iBAAiB;CAoChC;AAED,eAAO,MAAM,oBAAoB,sBAA6B,CAAC"}

package/services/local-inference/engine.js

@@ -0,0 +1,223 @@
+/**
+ * Standalone llama.cpp engine.
+ *
+ * Owns one `Llama` binding instance, at most one loaded `LlamaModel`, and
+ * a cached `LlamaChatSession` that wraps it. Model swap is unload-then-load
+ * so we never double-allocate VRAM.
+ *
+ * Two consumption paths:
+ *   1. The Model Hub UI calls `load()` / `unload()` to make "Activate" work.
+ *   2. The agent runtime calls `generate()` via the registered
+ *      `ModelType.TEXT_SMALL` / `TEXT_LARGE` handlers (see
+ *      `ensure-local-inference-handler.ts`).
+ *
+ * Dynamic import keeps the binding optional: if `node-llama-cpp` is not
+ * installed, `available()` returns false and callers surface a clear error
+ * instead of crashing the process.
+ */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { findCatalogModel } from "./catalog.js";
+import { dflashLlamaServer, dflashRequired, getDflashRuntimeStatus, } from "./dflash-server.js";
+import { listInstalledModels } from "./registry.js";
+const NODE_LLAMA_CPP_MODULE_ID = "node-llama-cpp";
+function normalizeKvCacheTypeForBinding(name) {
+    return name.trim().toUpperCase();
+}
+export class LocalInferenceEngine {
+    llama = null;
+    loadedModel = null;
+    loadedContext = null;
+    loadedSession = null;
+    loadedPath = null;
+    bindingChecked = false;
+    bindingModule = null;
+    /** Serialises generate calls so concurrent requests don't corrupt session state. */
+    generationQueue = Promise.resolve();
+    async available() {
+        if (!this.bindingChecked) {
+            this.bindingModule = await this.loadBinding();
+            this.bindingChecked = true;
+        }
+        return this.bindingModule !== null;
+    }
+    currentModelPath() {
+        if (dflashLlamaServer.hasLoadedModel()) {
+            return dflashLlamaServer.currentModelPath();
+        }
+        return this.loadedPath;
+    }
+    hasLoadedModel() {
+        return this.loadedModel !== null || dflashLlamaServer.hasLoadedModel();
+    }
+    async unload() {
+        await dflashLlamaServer.stop();
+        if (!this.loadedModel)
+            return;
+        const session = this.loadedSession;
+        const context = this.loadedContext;
+        const model = this.loadedModel;
+        this.loadedSession = null;
+        this.loadedContext = null;
+        this.loadedModel = null;
+        this.loadedPath = null;
+        // Dispose bottom-up: session first, then context, then the model. Each
+        // dispose is wrapped because a partial failure must not strand state.
+        try {
+            await session?.dispose?.();
+        }
+        catch {
+            /* best effort */
+        }
+        try {
+            await context?.dispose();
+        }
+        catch {
+            /* best effort */
+        }
+        await model.dispose();
+    }
+    async load(modelPath, resolved) {
+        if (this.loadedPath === modelPath && this.loadedModel)
+            return;
+        if (dflashLlamaServer.currentModelPath() === modelPath)
+            return;
+        const dflashPlan = await this.resolveDflashPlan(modelPath);
+        if (dflashPlan) {
+            try {
+                await this.unload();
+                await dflashLlamaServer.start(dflashPlan);
+                return;
+            }
+            catch (err) {
+                if (dflashRequired())
+                    throw err;
+                console.warn("[local-inference] DFlash llama-server unavailable; falling back to node-llama-cpp:", err instanceof Error ? err.message : String(err));
+            }
+        }
+        if (!(await this.available()) || !this.bindingModule) {
+            throw new Error("node-llama-cpp is not installed in this build; add it as a dependency to enable local inference");
+        }
+        if (this.loadedModel) {
+            await this.unload();
+        }
+        if (!this.llama) {
+            this.llama = await this.bindingModule.getLlama({ gpu: "auto" });
+        }
+        const model = await this.llama.loadModel({
+            modelPath,
+            gpuLayers: resolved?.gpuLayers ?? "auto",
+            useMmap: resolved?.mmap,
+            useMlock: resolved?.mlock,
+            defaultContextFlashAttention: resolved?.flashAttention,
+        });
+        const context = await model.createContext({
+            contextSize: resolved?.contextSize,
+            flashAttention: resolved?.flashAttention,
+            experimentalKvCacheKeyType: resolved?.cacheTypeK
+                ? normalizeKvCacheTypeForBinding(resolved.cacheTypeK)
+                : undefined,
+            experimentalKvCacheValueType: resolved?.cacheTypeV
+                ? normalizeKvCacheTypeForBinding(resolved.cacheTypeV)
+                : undefined,
+        });
+        const sequence = context.getSequence();
+        const session = new this.bindingModule.LlamaChatSession({
+            contextSequence: sequence,
+        });
+        this.loadedModel = model;
+        this.loadedContext = context;
+        this.loadedSession = session;
+        this.loadedPath = modelPath;
+    }
+    /**
+     * Generate text from the loaded model. Serialised — a new call waits for
+     * any in-flight generation to finish so the chat session's internal state
+     * stays consistent.
+     */
+    async generate(args) {
+        if (dflashLlamaServer.hasLoadedModel()) {
+            return dflashLlamaServer.generate(args);
+        }
+        if (!this.loadedSession) {
+            throw new Error("No local model is active. Select one in Settings → Local models before using local inference.");
+        }
+        const session = this.loadedSession;
+        const run = async () => {
+            // Agent model handlers are stateless per call. Drop any prior chat
+            // history so sequential prompts don't thread through accumulated
+            // context and drift output quality.
+            await session.resetChatHistory?.();
+            return session.prompt(args.prompt, {
+                maxTokens: args.maxTokens ?? 2048,
+                temperature: args.temperature ?? 0.7,
+                topP: args.topP ?? 0.9,
+                customStopTriggers: args.stopSequences,
+            });
+        };
+        const job = this.generationQueue.then(run, run);
+        this.generationQueue = job.catch(() => {
+            /* swallow so queue remains usable after a failure */
+        });
+        return job;
+    }
+    async loadBinding() {
+        try {
+            const mod = (await import(__rewriteRelativeImportExtension(
+            /* @vite-ignore */ NODE_LLAMA_CPP_MODULE_ID)));
+            if (mod &&
+                typeof mod === "object" &&
+                "getLlama" in mod &&
+                "LlamaChatSession" in mod &&
+                typeof mod.getLlama === "function") {
+                return mod;
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async resolveDflashPlan(modelPath) {
+        const installed = await listInstalledModels();
+        const target = installed.find((m) => m.path === modelPath);
+        if (!target)
+            return null;
+        const catalog = findCatalogModel(target.id);
+        const dflash = catalog?.runtime?.dflash;
+        if (!dflash)
+            return null;
+        const status = getDflashRuntimeStatus();
+        if (!status.enabled) {
+            if (status.required)
+                throw new Error(`[dflash] ${status.reason}`);
+            return null;
+        }
+        const drafter = installed.find((m) => m.id === dflash.drafterModelId);
+        if (!drafter) {
+            const message = `[dflash] ${catalog.displayName} requires companion drafter ${dflash.drafterModelId}. Download the model again or start a download for the companion id.`;
+            if (status.required)
+                throw new Error(message);
+            console.warn(`${message} Falling back to node-llama-cpp.`);
+            return null;
+        }
+        return {
+            targetModelPath: target.path,
+            drafterModelPath: drafter.path,
+            contextSize: dflash.contextSize,
+            draftContextSize: dflash.draftContextSize,
+            draftMin: dflash.draftMin,
+            draftMax: dflash.draftMax,
+            gpuLayers: dflash.gpuLayers,
+            draftGpuLayers: dflash.draftGpuLayers,
+            disableThinking: dflash.disableThinking,
+        };
+    }
+}
+export const localInferenceEngine = new LocalInferenceEngine();

package/services/local-inference/external-scanner.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Discover GGUF files already on disk from other local-inference tools.
+ *
+ * Users often have LM Studio, Jan, Ollama, or raw HuggingFace downloads
+ * lying around. We scan their default cache paths and surface those models
+ * in the Model Hub with `source: "external-scan"` so Eliza can load them
+ * without re-downloading. Eliza never modifies or deletes these files —
+ * the uninstall endpoint refuses when `source !== "eliza-download"`.
+ *
+ * Ollama is special: its blobs live under `models/blobs/sha256-*` with no
+ * `.gguf` extension, and the human name only exists in adjacent manifests.
+ * We parse the manifests to recover the mapping; blobs we can't map stay
+ * hidden rather than surfacing as opaque hashes.
+ */
+import type { InstalledModel } from "./types";
+export declare function scanExternalModels(): Promise<InstalledModel[]>;
+//# sourceMappingURL=external-scanner.d.ts.map

package/services/local-inference/external-scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"external-scanner.d.ts","sourceRoot":"","sources":["../../../../../../src/services/local-inference/external-scanner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AA6P9C,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC,CAuCpE"}

package/services/local-inference/external-scanner.js

@@ -0,0 +1,261 @@
+/**
+ * Discover GGUF files already on disk from other local-inference tools.
+ *
+ * Users often have LM Studio, Jan, Ollama, or raw HuggingFace downloads
+ * lying around. We scan their default cache paths and surface those models
+ * in the Model Hub with `source: "external-scan"` so Eliza can load them
+ * without re-downloading. Eliza never modifies or deletes these files —
+ * the uninstall endpoint refuses when `source !== "eliza-download"`.
+ *
+ * Ollama is special: its blobs live under `models/blobs/sha256-*` with no
+ * `.gguf` extension, and the human name only exists in adjacent manifests.
+ * We parse the manifests to recover the mapping; blobs we can't map stay
+ * hidden rather than surfacing as opaque hashes.
+ */
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+function candidateRoots() {
+    const home = os.homedir();
+    const platform = process.platform;
+    const roots = [];
+    // ── LM Studio ──────────────────────────────────────────────────────
+    roots.push({
+        origin: "lm-studio",
+        dir: path.join(home, ".lmstudio", "models"),
+        kind: "flat",
+    }, {
+        origin: "lm-studio",
+        dir: path.join(home, ".cache", "lm-studio", "models"),
+        kind: "flat",
+    });
+    // ── Jan ─────────────────────────────────────────────────────────────
+    if (platform === "darwin") {
+        roots.push({
+            origin: "jan",
+            dir: path.join(home, "Library", "Application Support", "Jan", "data", "models"),
+            kind: "flat",
+        });
+    }
+    else if (platform === "win32") {
+        const appdata = process.env.APPDATA ?? path.join(home, "AppData", "Roaming");
+        roots.push({
+            origin: "jan",
+            dir: path.join(appdata, "Jan", "data", "models"),
+            kind: "flat",
+        });
+    }
+    else {
+        const xdg = process.env.XDG_CONFIG_HOME ?? path.join(home, ".config");
+        roots.push({
+            origin: "jan",
+            dir: path.join(xdg, "Jan", "data", "models"),
+            kind: "flat",
+        });
+    }
+    // Legacy Jan path, still seen on older installs.
+    roots.push({
+        origin: "jan",
+        dir: path.join(home, "jan", "models"),
+        kind: "flat",
+    });
+    // ── Ollama ──────────────────────────────────────────────────────────
+    const ollamaOverride = process.env.OLLAMA_MODELS?.trim();
+    if (ollamaOverride) {
+        roots.push({ origin: "ollama", dir: ollamaOverride, kind: "ollama" });
+    }
+    roots.push({
+        origin: "ollama",
+        dir: path.join(home, ".ollama", "models"),
+        kind: "ollama",
+    });
+    if (platform === "linux") {
+        roots.push({
+            origin: "ollama",
+            dir: "/usr/share/ollama/.ollama/models",
+            kind: "ollama",
+        }, {
+            origin: "ollama",
+            dir: "/var/lib/ollama/.ollama/models",
+            kind: "ollama",
+        });
+    }
+    // ── HuggingFace hub ────────────────────────────────────────────────
+    const hfOverride = process.env.HF_HUB_CACHE?.trim() ||
+        (process.env.HF_HOME ? path.join(process.env.HF_HOME, "hub") : null);
+    const hfDefault = path.join(home, ".cache", "huggingface", "hub");
+    roots.push({
+        origin: "huggingface",
+        dir: hfOverride || hfDefault,
+        kind: "hf-snapshots",
+    });
+    // ── text-generation-webui ──────────────────────────────────────────
+    // Best-effort common install locations; users can symlink anything they
+    // want under here. We only pick up `.gguf` files.
+    roots.push({
+        origin: "text-gen-webui",
+        dir: path.join(home, "text-generation-webui", "user_data", "models"),
+        kind: "flat",
+    }, {
+        origin: "text-gen-webui",
+        dir: path.join(home, "text-generation-webui", "models"),
+        kind: "flat",
+    });
+    return roots;
+}
+async function dirExists(dir) {
+    try {
+        const stat = await fs.stat(dir);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function* walkForGgufs(root, maxDepth = 6) {
+    const stack = [
+        { dir: root, depth: 0 },
+    ];
+    while (stack.length > 0) {
+        const frame = stack.pop();
+        if (!frame)
+            break;
+        const { dir, depth } = frame;
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (depth < maxDepth)
+                    stack.push({ dir: full, depth: depth + 1 });
+                continue;
+            }
+            // HF snapshots are symlinks into ../blobs/; follow them.
+            const isLink = entry.isSymbolicLink();
+            if (!isLink && !entry.isFile())
+                continue;
+            if (!full.toLowerCase().endsWith(".gguf"))
+                continue;
+            try {
+                const realPath = isLink ? await fs.realpath(full) : full;
+                const stat = await fs.stat(realPath);
+                if (!stat.isFile())
+                    continue;
+                yield {
+                    absPath: full,
+                    realPath,
+                    size: stat.size,
+                    mtimeMs: stat.mtimeMs,
+                };
+            }
+            catch {
+                // Broken symlink or permission issue; skip silently.
+            }
+        }
+    }
+}
+async function scanOllama(root) {
+    const manifestsRoot = path.join(root, "manifests");
+    const blobsRoot = path.join(root, "blobs");
+    if (!(await dirExists(manifestsRoot)) || !(await dirExists(blobsRoot))) {
+        return [];
+    }
+    const results = [];
+    const stack = [manifestsRoot];
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        if (!dir)
+            break;
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(full);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            let manifest;
+            try {
+                const raw = await fs.readFile(full, "utf8");
+                manifest = JSON.parse(raw);
+            }
+            catch {
+                continue;
+            }
+            const modelLayer = manifest.layers?.find((l) => l.mediaType?.includes("model"));
+            if (!modelLayer?.digest)
+                continue;
+            const digest = modelLayer.digest.replace("sha256:", "sha256-");
+            const blobPath = path.join(blobsRoot, digest);
+            let size = modelLayer.size;
+            try {
+                const stat = await fs.stat(blobPath);
+                size = stat.size;
+            }
+            catch {
+                continue;
+            }
+            const relativeManifest = path.relative(manifestsRoot, full);
+            const displayName = `ollama: ${relativeManifest.split(path.sep).slice(-2).join(":")}`;
+            results.push({
+                id: `external-ollama-${digest}`,
+                displayName,
+                path: blobPath,
+                sizeBytes: size,
+                installedAt: new Date().toISOString(),
+                lastUsedAt: null,
+                source: "external-scan",
+                externalOrigin: "ollama",
+            });
+        }
+    }
+    return results;
+}
+export async function scanExternalModels() {
+    const roots = candidateRoots();
+    const seenRealPaths = new Set();
+    const results = [];
+    await Promise.all(roots.map(async (root) => {
+        if (!(await dirExists(root.dir)))
+            return;
+        if (root.kind === "ollama") {
+            const ollamaModels = await scanOllama(root.dir);
+            for (const model of ollamaModels) {
+                if (seenRealPaths.has(model.path))
+                    continue;
+                seenRealPaths.add(model.path);
+                results.push(model);
+            }
+            return;
+        }
+        for await (const found of walkForGgufs(root.dir)) {
+            if (seenRealPaths.has(found.realPath))
+                continue;
+            seenRealPaths.add(found.realPath);
+            const displayName = path.basename(found.absPath, ".gguf");
+            results.push({
+                id: `external-${root.origin}-${Buffer.from(found.realPath).toString("base64url").slice(0, 16)}`,
+                displayName: `${displayName} (${root.origin})`,
+                path: found.realPath,
+                sizeBytes: found.size,
+                installedAt: new Date(found.mtimeMs).toISOString(),
+                lastUsedAt: null,
+                source: "external-scan",
+                externalOrigin: root.origin,
+            });
+        }
+    }));
+    return results;
+}

package/services/local-inference/handler-registry.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Side-registry of model handlers registered on an AgentRuntime.
+ *
+ * The elizaOS core exposes `runtime.registerModel(type, handler, provider,
+ * priority)` but no way to list who registered what. This module intercepts
+ * `registerModel` at runtime to record every registration in a Map keyed by
+ * model type, plus fires status listeners so the UI can render a live
+ * [ModelType × Provider] routing table.
+ *
+ * Because we monkey-patch `registerModel` we also keep the original
+ * handler reference — the router-handler (see `router-handler.ts`) uses
+ * this to dispatch inference calls by policy without going through
+ * `runtime.useModel` (which would loop back to us and recurse).
+ */
+import { AgentRuntime, type IAgentRuntime } from "@elizaos/core";
+export interface HandlerRegistration {
+    modelType: string;
+    provider: string;
+    priority: number;
+    registeredAt: string;
+    /**
+     * The original handler function. Captured so the router-handler can
+     * dispatch to it directly, bypassing `runtime.useModel` which would
+     * re-enter the router itself.
+     */
+    handler: (runtime: IAgentRuntime, params: Record<string, unknown>) => Promise<unknown>;
+}
+type Listener = (registrations: HandlerRegistration[]) => void;
+declare class HandlerRegistry {
+    private readonly registrations;
+    private readonly listeners;
+    private installedOn;
+    /**
+     * Snapshot of all registrations grouped by model type, sorted by
+     * priority descending inside each group (matches core's selection
+     * order). Callers must not mutate the returned array.
+     */
+    getAll(): HandlerRegistration[];
+    /** All registrations for a given model type, sorted by priority desc. */
+    getForType(modelType: string): HandlerRegistration[];
+    /**
+     * Registrations excluding a specific provider. Used by the router-handler
+     * to find "all providers except me" when dispatching.
+     */
+    getForTypeExcluding(modelType: string, excludeProvider: string): HandlerRegistration[];
+    subscribe(listener: Listener): () => void;
+    private emit;
+    private record;
+    /**
+     * Install the interception on a runtime. Idempotent per runtime instance.
+     * For most boot paths the prototype-level patch below already covers the
+     * runtime before any plugin registers; this method is the belt-and-braces
+     * fallback for runtimes constructed before the patch ran.
+     */
+    installOn(runtime: AgentRuntime): void;
+    /** Exposed so the prototype patch can record through the singleton. */
+    recordFromPrototype(reg: HandlerRegistration): void;
+}
+export declare const handlerRegistry: HandlerRegistry;
+/**
+ * Public type used by the API/UI — omits the handler function for
+ * serialisation and to prevent UI code from accidentally calling it.
+ */
+export interface PublicRegistration {
+    modelType: string;
+    provider: string;
+    priority: number;
+    registeredAt: string;
+}
+export declare function toPublicRegistration(reg: HandlerRegistration): PublicRegistration;
+export {};
+//# sourceMappingURL=handler-registry.d.ts.map

package/services/local-inference/handler-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler-registry.d.ts","sourceRoot":"","sources":["../../../../../../src/services/local-inference/handler-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,YAAY,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAEjE,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,OAAO,EAAE,CACP,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC5B,OAAO,CAAC,OAAO,CAAC,CAAC;CACvB;AAED,KAAK,QAAQ,GAAG,CAAC,aAAa,EAAE,mBAAmB,EAAE,KAAK,IAAI,CAAC;AAE/D,cAAM,eAAe;IACnB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA4C;IAC1E,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuB;IACjD,OAAO,CAAC,WAAW,CAAkC;IAErD;;;;OAIG;IACH,MAAM,IAAI,mBAAmB,EAAE;IAQ/B,yEAAyE;IACzE,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,mBAAmB,EAAE;IAKpD;;;OAGG;IACH,mBAAmB,CACjB,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,MAAM,GACtB,mBAAmB,EAAE;IAMxB,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,IAAI;IAOzC,OAAO,CAAC,IAAI;IAWZ,OAAO,CAAC,MAAM;IAYd;;;;;OAKG;IACH,SAAS,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IA2CtC,uEAAuE;IACvE,mBAAmB,CAAC,GAAG,EAAE,mBAAmB,GAAG,IAAI;CAGpD;AAuED,eAAO,MAAM,eAAe,iBAAwB,CAAC;AAErD;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,mBAAmB,GACvB,kBAAkB,CAOpB"}