@elizaos/ui 2.0.0-alpha.526 → 2.0.0-alpha.528

package/packages/app-core/src/services/local-inference/handler-registry.js

@@ -0,0 +1,160 @@
+/**
+ * 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 } from "@elizaos/core";
+class HandlerRegistry {
+    registrations = new Map();
+    listeners = new Set();
+    installedOn = new WeakSet();
+    /**
+     * 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() {
+        const out = [];
+        for (const list of this.registrations.values()) {
+            out.push(...list);
+        }
+        return out;
+    }
+    /** All registrations for a given model type, sorted by priority desc. */
+    getForType(modelType) {
+        const list = this.registrations.get(modelType);
+        return list ? [...list] : [];
+    }
+    /**
+     * Registrations excluding a specific provider. Used by the router-handler
+     * to find "all providers except me" when dispatching.
+     */
+    getForTypeExcluding(modelType, excludeProvider) {
+        return this.getForType(modelType).filter((r) => r.provider !== excludeProvider);
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    emit() {
+        const snapshot = this.getAll();
+        for (const listener of this.listeners) {
+            try {
+                listener(snapshot);
+            }
+            catch {
+                this.listeners.delete(listener);
+            }
+        }
+    }
+    record(reg) {
+        const existing = this.registrations.get(reg.modelType) ?? [];
+        // Replace any prior registration from the same provider for this
+        // model type. Core allows multiple providers per type but only one
+        // registration per (type, provider) pair — last write wins.
+        const filtered = existing.filter((r) => r.provider !== reg.provider);
+        filtered.push(reg);
+        filtered.sort((a, b) => b.priority - a.priority);
+        this.registrations.set(reg.modelType, filtered);
+        this.emit();
+    }
+    /**
+     * 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) {
+        installPrototypePatch();
+        const rt = runtime;
+        if (typeof rt.registerModel !== "function")
+            return;
+        if (this.installedOn.has(rt))
+            return;
+        this.installedOn.add(rt);
+        // If the runtime already inherited the patched prototype method the
+        // prototype handles every call. Nothing to do per-instance.
+        const protoMethod = Object.getPrototypeOf(rt)?.registerModel;
+        if (protoMethod &&
+            protoMethod[PATCH_MARK]) {
+            return;
+        }
+        // Per-instance wrap only for legacy runtimes whose prototype pre-dates
+        // our prototype patch (shouldn't happen in practice).
+        const original = rt.registerModel.bind(runtime);
+        rt.registerModel = ((modelType, handler, provider, priority) => {
+            this.record({
+                modelType: String(modelType),
+                provider: String(provider),
+                priority: typeof priority === "number" ? priority : 0,
+                registeredAt: new Date().toISOString(),
+                handler,
+            });
+            return original(modelType, handler, provider, priority);
+        });
+    }
+    /** Exposed so the prototype patch can record through the singleton. */
+    recordFromPrototype(reg) {
+        this.record(reg);
+    }
+}
+const PATCH_MARK = Symbol.for("milady.local-inference.registerModel.patched");
+let prototypePatched = false;
+/**
+ * One-shot patch of `AgentRuntime.prototype.registerModel` so every runtime
+ * instance — including ones constructed later in boot — records through
+ * the singleton handler registry. Idempotent.
+ */
+function installPrototypePatch() {
+    if (prototypePatched)
+        return;
+    const proto = AgentRuntime.prototype;
+    const original = proto.registerModel;
+    if (typeof original !== "function")
+        return;
+    if (original[PATCH_MARK]) {
+        prototypePatched = true;
+        return;
+    }
+    const patched = function patchedRegisterModel(modelType, handler, provider, priority) {
+        try {
+            handlerRegistry.recordFromPrototype({
+                modelType: String(modelType),
+                provider: String(provider),
+                priority: typeof priority === "number" ? priority : 0,
+                registeredAt: new Date().toISOString(),
+                handler,
+            });
+        }
+        catch {
+            // Never let registry bookkeeping break the registration path.
+        }
+        original.call(this, modelType, handler, provider, priority);
+    };
+    patched[PATCH_MARK] = true;
+    proto.registerModel = patched;
+    prototypePatched = true;
+}
+// Install at module-import time. This is a process-wide side effect but a
+// benign one: the patch is idempotent and forwards to the original.
+installPrototypePatch();
+export const handlerRegistry = new HandlerRegistry();
+export function toPublicRegistration(reg) {
+    return {
+        modelType: reg.modelType,
+        provider: reg.provider,
+        priority: reg.priority,
+        registeredAt: reg.registeredAt,
+    };
+}

package/packages/app-core/src/services/local-inference/paths.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Path resolution for the local-inference service.
+ *
+ * All Milady-owned files live under `$STATE_DIR/local-inference/` to match
+ * the convention established by `plugin-installer.ts` and the rest of
+ * app-core. We never write to paths outside of this root.
+ *
+ * The state dir is resolved in `MILADY_STATE_DIR` → `ELIZA_STATE_DIR` →
+ * `~/.eliza` order. The `.eliza` fallback is preserved for desktop
+ * backward-compat with existing installs; on AOSP `MILADY_STATE_DIR` is
+ * set by `MiladyAgentService.java` to `/data/data/<pkg>/files/.milady`,
+ * so models land at `<that>/local-inference/models/` and not under a
+ * stray homedir-derived path.
+ */
+export declare function localInferenceRoot(): string;
+/** Directory for models Milady downloaded itself. Safe to delete. */
+export declare function miladyModelsDir(): string;
+/** JSON file tracking installed-model metadata (downloaded + discovered). */
+export declare function registryPath(): string;
+/** Partial-download staging directory; files here are resume candidates. */
+export declare function downloadsStagingDir(): string;
+/** True when `target` is inside Milady's local-inference root. */
+export declare function isWithinMiladyRoot(target: string): boolean;
+//# sourceMappingURL=paths.d.ts.map

package/packages/app-core/src/services/local-inference/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../../../../../app-core/src/services/local-inference/paths.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH,wBAAgB,kBAAkB,IAAI,MAAM,CAK3C;AAED,qEAAqE;AACrE,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED,6EAA6E;AAC7E,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAED,4EAA4E;AAC5E,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C;AAED,kEAAkE;AAClE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAK1D"}

package/packages/app-core/src/services/local-inference/paths.js

@@ -0,0 +1,41 @@
+/**
+ * Path resolution for the local-inference service.
+ *
+ * All Milady-owned files live under `$STATE_DIR/local-inference/` to match
+ * the convention established by `plugin-installer.ts` and the rest of
+ * app-core. We never write to paths outside of this root.
+ *
+ * The state dir is resolved in `MILADY_STATE_DIR` → `ELIZA_STATE_DIR` →
+ * `~/.eliza` order. The `.eliza` fallback is preserved for desktop
+ * backward-compat with existing installs; on AOSP `MILADY_STATE_DIR` is
+ * set by `MiladyAgentService.java` to `/data/data/<pkg>/files/.milady`,
+ * so models land at `<that>/local-inference/models/` and not under a
+ * stray homedir-derived path.
+ */
+import os from "node:os";
+import path from "node:path";
+export function localInferenceRoot() {
+    const stateDir = process.env.MILADY_STATE_DIR?.trim() || process.env.ELIZA_STATE_DIR?.trim();
+    const base = stateDir || path.join(os.homedir(), ".eliza");
+    return path.join(base, "local-inference");
+}
+/** Directory for models Milady downloaded itself. Safe to delete. */
+export function miladyModelsDir() {
+    return path.join(localInferenceRoot(), "models");
+}
+/** JSON file tracking installed-model metadata (downloaded + discovered). */
+export function registryPath() {
+    return path.join(localInferenceRoot(), "registry.json");
+}
+/** Partial-download staging directory; files here are resume candidates. */
+export function downloadsStagingDir() {
+    return path.join(localInferenceRoot(), "downloads");
+}
+/** True when `target` is inside Milady's local-inference root. */
+export function isWithinMiladyRoot(target) {
+    const root = path.resolve(localInferenceRoot());
+    const resolved = path.resolve(target);
+    if (resolved === root)
+        return false;
+    return resolved.startsWith(`${root}${path.sep}`);
+}

package/packages/app-core/src/services/local-inference/providers.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Provider registry.
+ *
+ * Treats every inference source the same way — cloud subscription, cloud
+ * API, local llama.cpp engine, paired-device bridge, Capacitor on-device
+ * — each is a `ProviderDefinition` with an `id`, a human label, a set of
+ * supported model slots, and a pluggable `getEnableState()` that inspects
+ * whatever underlying gate controls it (API key presence, subscription
+ * status, env flag, file on disk).
+ *
+ * The cloud-provider status readers are intentionally permissive: they
+ * report what they can introspect without depending on the specific
+ * cloud-plugin internals, and hand off to the existing ProviderSwitcher
+ * UI for actual enable/disable via `configureHref`. That avoids the
+ * "combined enable matrix is an architectural project" problem by making
+ * configuration navigable rather than centralised.
+ */
+import type { AgentModelSlot } from "./types";
+export type ProviderId = "milady-local-inference" | "milady-device-bridge" | "capacitor-llama" | "anthropic-subscription" | "openai-codex" | "anthropic" | "openai" | "grok" | "elizacloud" | "google" | "mistral";
+export interface ProviderEnableState {
+    enabled: boolean;
+    /** Short reason, e.g. "API key set", "Device connected", "No API key". */
+    reason: string;
+}
+export interface ProviderDefinition {
+    id: ProviderId;
+    label: string;
+    kind: "cloud-api" | "cloud-subscription" | "local" | "device-bridge";
+    /** Short blurb shown in the UI. */
+    description: string;
+    /** Agent slots this provider can plausibly serve. */
+    supportedSlots: AgentModelSlot[];
+    /**
+     * Read the current enable state. For cloud providers we inspect env
+     * vars or config fragments; for local we check file presence; for
+     * device-bridge we check connected-device count.
+     */
+    getEnableState(): Promise<ProviderEnableState>;
+    /**
+     * Link to the settings UI where enable/configure actually happens.
+     * UI sends the user here via anchor-scroll when they click "Configure".
+     * `null` means the provider has no separate config surface.
+     */
+    configureHref: string | null;
+}
+/** Resolve which slots have at least one registered handler from this provider. */
+export declare function getRegisteredSlotsForProvider(providerId: string): string[];
+export declare const BUILT_IN_PROVIDERS: readonly ProviderDefinition[];
+export interface ProviderStatus {
+    id: ProviderId;
+    label: string;
+    kind: ProviderDefinition["kind"];
+    description: string;
+    supportedSlots: AgentModelSlot[];
+    configureHref: string | null;
+    enableState: ProviderEnableState;
+    /** Registered model types this provider has handlers for, right now. */
+    registeredSlots: string[];
+}
+export declare function snapshotProviders(): Promise<ProviderStatus[]>;
+//# sourceMappingURL=providers.d.ts.map

package/packages/app-core/src/services/local-inference/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../../../../../../app-core/src/services/local-inference/providers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAOH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,MAAM,MAAM,UAAU,GAClB,wBAAwB,GACxB,sBAAsB,GACtB,iBAAiB,GACjB,wBAAwB,GACxB,cAAc,GACd,WAAW,GACX,QAAQ,GACR,MAAM,GACN,YAAY,GACZ,QAAQ,GACR,SAAS,CAAC;AAEd,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,0EAA0E;IAC1E,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,UAAU,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,WAAW,GAAG,oBAAoB,GAAG,OAAO,GAAG,eAAe,CAAC;IACrE,mCAAmC;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,qDAAqD;IACrD,cAAc,EAAE,cAAc,EAAE,CAAC;IACjC;;;;OAIG;IACH,cAAc,IAAI,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAC/C;;;;OAIG;IACH,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED,mFAAmF;AACnF,wBAAgB,6BAA6B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAO1E;AAiOD,eAAO,MAAM,kBAAkB,EAAE,SAAS,kBAAkB,EAY3D,CAAC;AAqBF,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,UAAU,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,cAAc,EAAE,CAAC;IACjC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,WAAW,EAAE,mBAAmB,CAAC;IACjC,wEAAwE;IACxE,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC,CAiBnE"}

package/packages/app-core/src/services/local-inference/providers.js

@@ -0,0 +1,277 @@
+/**
+ * Provider registry.
+ *
+ * Treats every inference source the same way — cloud subscription, cloud
+ * API, local llama.cpp engine, paired-device bridge, Capacitor on-device
+ * — each is a `ProviderDefinition` with an `id`, a human label, a set of
+ * supported model slots, and a pluggable `getEnableState()` that inspects
+ * whatever underlying gate controls it (API key presence, subscription
+ * status, env flag, file on disk).
+ *
+ * The cloud-provider status readers are intentionally permissive: they
+ * report what they can introspect without depending on the specific
+ * cloud-plugin internals, and hand off to the existing ProviderSwitcher
+ * UI for actual enable/disable via `configureHref`. That avoids the
+ * "combined enable matrix is an architectural project" problem by making
+ * configuration navigable rather than centralised.
+ */
+import fs from "node:fs/promises";
+import { getDefaultAccountPool } from "../account-pool";
+import { deviceBridge } from "./device-bridge";
+import { handlerRegistry } from "./handler-registry";
+import { localInferenceRoot } from "./paths";
+/** Resolve which slots have at least one registered handler from this provider. */
+export function getRegisteredSlotsForProvider(providerId) {
+    const regs = handlerRegistry.getAll();
+    const slots = new Set();
+    for (const r of regs) {
+        if (r.provider === providerId)
+            slots.add(r.modelType);
+    }
+    return [...slots];
+}
+// ── Built-in provider definitions ────────────────────────────────────
+const LOCAL_PROVIDER = {
+    id: "milady-local-inference",
+    label: "Local llama.cpp",
+    kind: "local",
+    description: "On-device inference using node-llama-cpp. Free, private, runs on your machine's CPU/GPU.",
+    supportedSlots: ["TEXT_SMALL", "TEXT_LARGE"],
+    async getEnableState() {
+        // Enabled when at least one model file lives under our root and the
+        // binding is loadable. We don't force-load node-llama-cpp here — that
+        // would tie up GPU memory just for a status probe.
+        try {
+            const entries = await fs.readdir(`${localInferenceRoot()}/models`, {
+                withFileTypes: true,
+            });
+            const hasModel = entries.some((e) => e.isFile() && e.name.toLowerCase().endsWith(".gguf"));
+            return hasModel
+                ? { enabled: true, reason: "GGUF model installed" }
+                : { enabled: false, reason: "No local model installed" };
+        }
+        catch {
+            return { enabled: false, reason: "No local model installed" };
+        }
+    },
+    configureHref: "#local-inference-panel",
+};
+const DEVICE_BRIDGE_PROVIDER = {
+    id: "milady-device-bridge",
+    label: "Paired device bridge",
+    kind: "device-bridge",
+    description: "Inference on a paired mobile or desktop device over WebSocket. Useful when the agent runs in a container but the model lives on your phone or laptop.",
+    supportedSlots: ["TEXT_SMALL", "TEXT_LARGE"],
+    async getEnableState() {
+        const bridgeEnabled = process.env.ELIZA_DEVICE_BRIDGE_ENABLED?.trim() === "1";
+        if (!bridgeEnabled) {
+            return {
+                enabled: false,
+                reason: "Set ELIZA_DEVICE_BRIDGE_ENABLED=1 to enable",
+            };
+        }
+        const status = deviceBridge.status();
+        if (status.connected) {
+            return {
+                enabled: true,
+                reason: `${status.devices.length} device(s) connected`,
+            };
+        }
+        return {
+            enabled: true,
+            reason: "Waiting for a device to connect",
+        };
+    },
+    configureHref: "#device-bridge-status",
+};
+const CAPACITOR_LLAMA_PROVIDER = {
+    id: "capacitor-llama",
+    label: "On-device llama.cpp (mobile)",
+    kind: "local",
+    description: "Runs llama.cpp natively on iOS or Android via Capacitor. Only available in mobile builds.",
+    supportedSlots: ["TEXT_SMALL", "TEXT_LARGE"],
+    async getEnableState() {
+        const cap = globalThis.Capacitor;
+        if (cap?.isNativePlatform?.()) {
+            return {
+                enabled: true,
+                reason: "Native Capacitor runtime detected",
+            };
+        }
+        return {
+            enabled: false,
+            reason: "Only available in iOS/Android builds",
+        };
+    },
+    configureHref: null,
+};
+const ANTHROPIC_PROVIDER = {
+    id: "anthropic",
+    label: "Anthropic API",
+    kind: "cloud-api",
+    description: "Claude models via the Anthropic API. Requires an API key.",
+    supportedSlots: ["TEXT_SMALL", "TEXT_LARGE", "OBJECT_SMALL", "OBJECT_LARGE"],
+    async getEnableState() {
+        const key = process.env.ANTHROPIC_API_KEY?.trim();
+        return key
+            ? { enabled: true, reason: "API key set" }
+            : { enabled: false, reason: "No API key" };
+    },
+    configureHref: "#ai-model",
+};
+const OPENAI_PROVIDER = {
+    id: "openai",
+    label: "OpenAI API",
+    kind: "cloud-api",
+    description: "GPT models via the OpenAI API. Requires an API key.",
+    supportedSlots: [
+        "TEXT_SMALL",
+        "TEXT_LARGE",
+        "TEXT_EMBEDDING",
+        "OBJECT_SMALL",
+        "OBJECT_LARGE",
+    ],
+    async getEnableState() {
+        const key = process.env.OPENAI_API_KEY?.trim();
+        return key
+            ? { enabled: true, reason: "API key set" }
+            : { enabled: false, reason: "No API key" };
+    },
+    configureHref: "#ai-model",
+};
+const GROK_PROVIDER = {
+    id: "grok",
+    label: "Grok API",
+    kind: "cloud-api",
+    description: "xAI Grok models. Requires an API key.",
+    supportedSlots: ["TEXT_SMALL", "TEXT_LARGE"],
+    async getEnableState() {
+        const key = process.env.GROK_API_KEY?.trim() ?? process.env.XAI_API_KEY?.trim();
+        return key
+            ? { enabled: true, reason: "API key set" }
+            : { enabled: false, reason: "No API key" };
+    },
+    configureHref: "#ai-model",
+};
+const ELIZACLOUD_PROVIDER = {
+    id: "elizacloud",
+    label: "Eliza Cloud",
+    kind: "cloud-subscription",
+    description: "Milady-hosted inference routed through your subscription. No API key to manage.",
+    supportedSlots: [
+        "TEXT_SMALL",
+        "TEXT_LARGE",
+        "TEXT_EMBEDDING",
+        "OBJECT_SMALL",
+        "OBJECT_LARGE",
+    ],
+    async getEnableState() {
+        const token = process.env.ELIZA_CLOUD_TOKEN?.trim() ??
+            process.env.ELIZACLOUD_TOKEN?.trim() ??
+            process.env.ELIZAOS_API_KEY?.trim();
+        return token
+            ? { enabled: true, reason: "Cloud token set" }
+            : { enabled: false, reason: "Not signed in" };
+    },
+    configureHref: "#ai-model",
+};
+const ANTHROPIC_SUBSCRIPTION_PROVIDER = {
+    id: "anthropic-subscription",
+    label: "Claude subscription",
+    kind: "cloud-subscription",
+    description: "Claude Code task-agent access through linked accounts.",
+    // Claude.ai OAuth subscriptions serve text + structured-object generation
+    // through Anthropic's chat models. Embeddings are not exposed by the
+    // subscription path (Anthropic does not ship an embeddings endpoint), so
+    // TEXT_EMBEDDING is intentionally omitted — that slot needs a separate
+    // API-key provider.
+    supportedSlots: ["TEXT_SMALL", "TEXT_LARGE", "OBJECT_SMALL", "OBJECT_LARGE"],
+    async getEnableState() {
+        return subscriptionEnableState("anthropic-subscription");
+    },
+    configureHref: "#ai-model",
+};
+const OPENAI_CODEX_PROVIDER = {
+    id: "openai-codex",
+    label: "Codex subscription",
+    kind: "cloud-subscription",
+    description: "Codex and ChatGPT subscription access through linked accounts.",
+    supportedSlots: ["TEXT_SMALL", "TEXT_LARGE", "OBJECT_SMALL", "OBJECT_LARGE"],
+    async getEnableState() {
+        return subscriptionEnableState("openai-codex");
+    },
+    configureHref: "#ai-model",
+};
+const GOOGLE_PROVIDER = {
+    id: "google",
+    label: "Google (Gemini)",
+    kind: "cloud-api",
+    description: "Gemini models via Google Generative AI. Requires an API key.",
+    supportedSlots: ["TEXT_SMALL", "TEXT_LARGE", "OBJECT_SMALL", "OBJECT_LARGE"],
+    async getEnableState() {
+        const key = process.env.GOOGLE_API_KEY?.trim() ?? process.env.GEMINI_API_KEY?.trim();
+        return key
+            ? { enabled: true, reason: "API key set" }
+            : { enabled: false, reason: "No API key" };
+    },
+    configureHref: "#ai-model",
+};
+const MISTRAL_PROVIDER = {
+    id: "mistral",
+    label: "Mistral API",
+    kind: "cloud-api",
+    description: "Mistral models via la Plateforme. Requires an API key.",
+    supportedSlots: ["TEXT_SMALL", "TEXT_LARGE"],
+    async getEnableState() {
+        const key = process.env.MISTRAL_API_KEY?.trim();
+        return key
+            ? { enabled: true, reason: "API key set" }
+            : { enabled: false, reason: "No API key" };
+    },
+    configureHref: "#ai-model",
+};
+export const BUILT_IN_PROVIDERS = [
+    LOCAL_PROVIDER,
+    DEVICE_BRIDGE_PROVIDER,
+    CAPACITOR_LLAMA_PROVIDER,
+    ANTHROPIC_SUBSCRIPTION_PROVIDER,
+    OPENAI_CODEX_PROVIDER,
+    ELIZACLOUD_PROVIDER,
+    ANTHROPIC_PROVIDER,
+    OPENAI_PROVIDER,
+    GOOGLE_PROVIDER,
+    GROK_PROVIDER,
+    MISTRAL_PROVIDER,
+];
+function subscriptionEnableState(providerId) {
+    if (providerId !== "anthropic-subscription" &&
+        providerId !== "openai-codex") {
+        return { enabled: false, reason: "Unsupported subscription" };
+    }
+    const accounts = getDefaultAccountPool()
+        .list(providerId)
+        .filter((account) => account.enabled && account.health === "ok");
+    if (accounts.length === 0) {
+        return { enabled: false, reason: "No linked account" };
+    }
+    return {
+        enabled: true,
+        reason: `${accounts.length} linked account${accounts.length === 1 ? "" : "s"}`,
+    };
+}
+export async function snapshotProviders() {
+    const entries = await Promise.all(BUILT_IN_PROVIDERS.map(async (def) => {
+        const state = await def.getEnableState();
+        return {
+            id: def.id,
+            label: def.label,
+            kind: def.kind,
+            description: def.description,
+            supportedSlots: def.supportedSlots,
+            configureHref: def.configureHref,
+            enableState: state,
+            registeredSlots: getRegisteredSlotsForProvider(def.id),
+        };
+    }));
+    return entries;
+}

package/packages/app-core/src/services/local-inference/registry.d.ts

@@ -0,0 +1,35 @@
+/**
+ * On-disk registry of installed models.
+ *
+ * Two sources feed the registry:
+ *   1. Milady-owned downloads (source: "milady-download") — written on
+ *      successful completion by the downloader.
+ *   2. External scans (source: "external-scan") — merged in at read time
+ *      from `scanExternalModels()`. These are never persisted to the
+ *      registry file; a rescan runs whenever we read.
+ *
+ * The JSON file only holds Milady-owned entries. That way, if a user
+ * cleans up LM Studio models we don't show stale ghosts.
+ */
+import type { InstalledModel } from "./types";
+/**
+ * Return all models currently usable: persisted Milady downloads plus a
+ * fresh external-tool scan. External duplicates of Milady-owned files are
+ * filtered out by path.
+ */
+export declare function listInstalledModels(): Promise<InstalledModel[]>;
+/** Add or update a Milady-owned entry. External entries are rejected. */
+export declare function upsertMiladyModel(model: InstalledModel): Promise<void>;
+/** Mark an existing Milady-owned model as most-recently-used. */
+export declare function touchMiladyModel(id: string): Promise<void>;
+/**
+ * Delete a Milady-owned model from the registry and from disk.
+ *
+ * Refuses if the model was discovered from another tool — Milady must not
+ * touch files it doesn't own. Callers surface that refusal as a 4xx.
+ */
+export declare function removeMiladyModel(id: string): Promise<{
+    removed: boolean;
+    reason?: "external" | "not-found";
+}>;
+//# sourceMappingURL=registry.d.ts.map

package/packages/app-core/src/services/local-inference/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../../../../app-core/src/services/local-inference/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAmC9C;;;;GAIG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC,CAcrE;AAED,yEAAyE;AACzE,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAe5E;AAED,iEAAiE;AACjE,wBAAsB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAMhE;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAC3D,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,UAAU,GAAG,WAAW,CAAC;CACnC,CAAC,CAyBD"}