@elizaos/ui 2.0.0-alpha.84 → 2.0.0-beta.1

package/dist/services/local-inference/hf-search.d.ts

@@ -0,0 +1,19 @@
+/**
+ * HuggingFace Hub search for GGUF models.
+ *
+ * Calls `https://huggingface.co/api/models` with `filter=gguf` to narrow
+ * results to repos that actually ship GGUF quantisations. Each matching
+ * repo is expanded with `/api/models/<repo>` to pick a representative
+ * quant file (preferring Q4_K_M when present). Results are shaped like
+ * `CatalogModel` so the existing ModelCard renders them directly.
+ *
+ * We deliberately do not persist these — they're dynamic, and a curated
+ * entry with the same hfRepo always takes precedence in the UI.
+ */
+import type { CatalogModel } from "./types";
+/**
+ * Search HuggingFace for GGUF repos matching `query`, returning
+ * catalog-shaped entries ready for the Model Hub UI.
+ */
+export declare function searchHuggingFaceGguf(query: string, limit?: number): Promise<CatalogModel[]>;
+//# sourceMappingURL=hf-search.d.ts.map

package/dist/services/local-inference/hf-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hf-search.d.ts","sourceRoot":"","sources":["../../../../../../src/services/local-inference/hf-search.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAe,MAAM,SAAS,CAAC;AAsIzD;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,MAAM,EACb,KAAK,SAAK,GACT,OAAO,CAAC,YAAY,EAAE,CAAC,CA+EzB"}

package/dist/services/local-inference/hf-search.js

@@ -0,0 +1,169 @@
+/**
+ * HuggingFace Hub search for GGUF models.
+ *
+ * Calls `https://huggingface.co/api/models` with `filter=gguf` to narrow
+ * results to repos that actually ship GGUF quantisations. Each matching
+ * repo is expanded with `/api/models/<repo>` to pick a representative
+ * quant file (preferring Q4_K_M when present). Results are shaped like
+ * `CatalogModel` so the existing ModelCard renders them directly.
+ *
+ * We deliberately do not persist these — they're dynamic, and a curated
+ * entry with the same hfRepo always takes precedence in the UI.
+ */
+const HF_API = "https://huggingface.co/api";
+const SEARCH_TIMEOUT_MS = 10_000;
+const QUANT_PREFERENCE = [
+    "Q4_K_M",
+    "Q5_K_M",
+    "Q4_0",
+    "Q5_0",
+    "Q3_K_M",
+    "Q8_0",
+    "Q2_K",
+];
+function pickQuantFile(siblings) {
+    const ggufs = siblings.filter((s) => s.rfilename?.toLowerCase().endsWith(".gguf"));
+    if (ggufs.length === 0)
+        return null;
+    for (const quant of QUANT_PREFERENCE) {
+        const match = ggufs.find((s) => s.rfilename?.toUpperCase().includes(quant));
+        if (match)
+            return match;
+    }
+    // No preferred quant — pick the smallest GGUF so we don't surprise the
+    // user with a 40 GB file.
+    return [...ggufs].sort((a, b) => (a.size ?? 0) - (b.size ?? 0))[0] ?? null;
+}
+function extractQuantLabel(filename) {
+    for (const quant of QUANT_PREFERENCE) {
+        if (filename.toUpperCase().includes(quant))
+            return quant;
+    }
+    return "GGUF";
+}
+/**
+ * Very rough parameter-count inference from model name / tags. We use this
+ * only to pick a bucket label — not for any hard memory check.
+ */
+function inferParams(name, tags) {
+    const lower = `${name} ${tags.join(" ")}`.toLowerCase();
+    const sizes = [
+        [/\b32b\b/, "32B", "xl"],
+        [/\b27b\b/, "27B", "large"],
+        [/\b24b\b/, "24B", "large"],
+        [/\b22b\b/, "22B", "large"],
+        [/\b16b\b/, "16B", "large"],
+        [/\b14b\b/, "14B", "large"],
+        [/\b13b\b/, "14B", "large"],
+        [/\b9b\b/, "9B", "mid"],
+        [/\b8b\b/, "8B", "mid"],
+        [/\b7b\b/, "7B", "mid"],
+        [/\b3b\b/, "3B", "small"],
+        [/\b1\.7b\b/, "1.7B", "small"],
+        [/\b1b\b/, "1B", "small"],
+    ];
+    for (const [re, params, bucket] of sizes) {
+        if (re.test(lower))
+            return { params, bucket };
+    }
+    return { params: "7B", bucket: "mid" };
+}
+function inferCategory(tags, pipelineTag) {
+    const lowerTags = tags.map((t) => t.toLowerCase());
+    if (lowerTags.some((t) => t.includes("code") || t.includes("coder"))) {
+        return "code";
+    }
+    if (lowerTags.some((t) => t.includes("reasoning") || t === "math" || t.includes("r1"))) {
+        return "reasoning";
+    }
+    if (lowerTags.some((t) => t.includes("function") || t.includes("tool") || t.includes("hermes"))) {
+        return "tools";
+    }
+    if (pipelineTag === "text-generation") {
+        return "chat";
+    }
+    return "chat";
+}
+async function fetchWithTimeout(url, init) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), SEARCH_TIMEOUT_MS);
+    try {
+        return await fetch(url, { ...init, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Search HuggingFace for GGUF repos matching `query`, returning
+ * catalog-shaped entries ready for the Model Hub UI.
+ */
+export async function searchHuggingFaceGguf(query, limit = 12) {
+    const trimmed = query.trim();
+    if (trimmed.length === 0)
+        return [];
+    const searchUrl = new URL(`${HF_API}/models`);
+    searchUrl.searchParams.set("search", trimmed);
+    searchUrl.searchParams.set("filter", "gguf");
+    searchUrl.searchParams.set("limit", String(Math.min(50, Math.max(1, limit * 2))));
+    searchUrl.searchParams.set("sort", "downloads");
+    searchUrl.searchParams.set("direction", "-1");
+    const searchRes = await fetchWithTimeout(searchUrl.toString(), {
+        headers: { accept: "application/json" },
+    });
+    if (!searchRes.ok) {
+        throw new Error(`HuggingFace search failed: HTTP ${searchRes.status}`);
+    }
+    const rawList = (await searchRes.json());
+    const candidates = rawList
+        .map((r) => r.id ?? r.modelId)
+        .filter((id) => typeof id === "string" && id.length > 0)
+        .slice(0, limit);
+    // Parallel detail fetches; failures drop quietly so one bad repo doesn't
+    // take down the whole search.
+    const details = await Promise.all(candidates.map(async (id) => {
+        try {
+            const res = await fetchWithTimeout(`${HF_API}/models/${encodeURIComponent(id)}`, { headers: { accept: "application/json" } });
+            if (!res.ok)
+                return null;
+            return (await res.json());
+        }
+        catch {
+            return null;
+        }
+    }));
+    const results = [];
+    for (let i = 0; i < candidates.length; i++) {
+        const id = candidates[i];
+        const detail = details[i];
+        if (!id || !detail?.siblings)
+            continue;
+        const sibling = pickQuantFile(detail.siblings);
+        if (!sibling?.rfilename)
+            continue;
+        const sizeBytes = sibling.size ?? 0;
+        const sizeGb = sizeBytes > 0 ? sizeBytes / 1024 ** 3 : 4;
+        const { params, bucket } = inferParams(id, detail.tags ?? []);
+        const quant = extractQuantLabel(sibling.rfilename);
+        const category = inferCategory(detail.tags ?? [], detail.pipeline_tag);
+        const displayName = id.split("/").pop() ?? id;
+        // minRam heuristic: 2x the file size, minimum 4 GB. Close enough for
+        // the fit badge; the ModelCard's fit computation still does the work.
+        const minRamGb = Math.max(4, Math.round(sizeGb * 2));
+        results.push({
+            id: `hf:${id}::${sibling.rfilename}`,
+            displayName,
+            hfRepo: id,
+            ggufFile: sibling.rfilename,
+            params,
+            quant,
+            sizeGb: Math.round(sizeGb * 10) / 10,
+            minRamGb,
+            category,
+            bucket,
+            blurb: (detail.tags ?? []).slice(0, 4).join(" · ") ||
+                `${detail.downloads ?? 0} downloads · ${detail.likes ?? 0} likes`,
+        });
+    }
+    return results;
+}

package/dist/services/local-inference/index.d.ts

@@ -0,0 +1,9 @@
+export type { LocalInferenceLoader } from "./active-model";
+export { ELIZA_1_PLACEHOLDER_IDS, findCatalogModel, FIRST_RUN_DEFAULT_MODEL_ID, MODEL_CATALOG, } from "./catalog";
+export { getDflashRuntimeStatus } from "./dflash-server";
+export { assessFit, probeHardware } from "./hardware";
+export { buildTextGenerationReadiness } from "./readiness";
+export { assessCatalogModelFit, catalogDownloadSizeBytes, catalogDownloadSizeGb, chooseSmallerFallbackModel, classifyRecommendationPlatform, type RecommendationPlatformClass, recommendForFirstRun, type RecommendedModelSelection, selectRecommendedModelForSlot, selectRecommendedModels, } from "./recommendation";
+export { LocalInferenceService, localInferenceService } from "./service";
+export type { ActiveModelState, CatalogModel, DownloadEvent, DownloadJob, DownloadState, HardwareFitLevel, HardwareProbe, InstalledModel, LocalInferenceDownloadStatus, LocalInferenceReadiness, LocalInferenceSlotReadiness, ModelBucket, ModelCategory, ModelHubSnapshot, TextGenerationSlot, } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/services/local-inference/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/services/local-inference/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,0BAA0B,EAC1B,aAAa,GACd,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,EACL,qBAAqB,EACrB,wBAAwB,EACxB,qBAAqB,EACrB,0BAA0B,EAC1B,8BAA8B,EAC9B,KAAK,2BAA2B,EAChC,oBAAoB,EACpB,KAAK,yBAAyB,EAC9B,6BAA6B,EAC7B,uBAAuB,GACxB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AACzE,YAAY,EACV,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,4BAA4B,EAC5B,uBAAuB,EACvB,2BAA2B,EAC3B,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,SAAS,CAAC"}

package/dist/services/local-inference/index.js

@@ -0,0 +1,6 @@
+export { ELIZA_1_PLACEHOLDER_IDS, findCatalogModel, FIRST_RUN_DEFAULT_MODEL_ID, MODEL_CATALOG, } from "./catalog.js";
+export { getDflashRuntimeStatus } from "./dflash-server.js";
+export { assessFit, probeHardware } from "./hardware.js";
+export { buildTextGenerationReadiness } from "./readiness.js";
+export { assessCatalogModelFit, catalogDownloadSizeBytes, catalogDownloadSizeGb, chooseSmallerFallbackModel, classifyRecommendationPlatform, recommendForFirstRun, selectRecommendedModelForSlot, selectRecommendedModels, } from "./recommendation.js";
+export { LocalInferenceService, localInferenceService } from "./service.js";

package/dist/services/local-inference/paths.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Re-export of the shared `local-inference` path resolution. The
+ * canonical implementation lives in `@elizaos/shared/local-inference`
+ * because both the server (`@elizaos/app-core`) and the UI client
+ * (`@elizaos/ui`) need byte-identical path semantics.
+ */
+export { downloadsStagingDir, elizaModelsDir, isWithinElizaRoot, localInferenceRoot, registryPath, } from "@elizaos/shared";
+//# sourceMappingURL=paths.d.ts.map

package/dist/services/local-inference/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../../../../src/services/local-inference/paths.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAClB,YAAY,GACb,MAAM,iBAAiB,CAAC"}

package/dist/services/local-inference/paths.js

@@ -0,0 +1,7 @@
+/**
+ * Re-export of the shared `local-inference` path resolution. The
+ * canonical implementation lives in `@elizaos/shared/local-inference`
+ * because both the server (`@elizaos/app-core`) and the UI client
+ * (`@elizaos/ui`) need byte-identical path semantics.
+ */
+export { downloadsStagingDir, elizaModelsDir, isWithinElizaRoot, localInferenceRoot, registryPath, } from "@elizaos/shared";

package/dist/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 = "eliza-local-inference" | "eliza-device-bridge" | "capacitor-llama" | "anthropic-subscription" | "openai-codex" | "anthropic" | "openai" | "deepseek" | "zai" | "moonshot" | "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/dist/services/local-inference/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../../../../../src/services/local-inference/providers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAOH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,MAAM,MAAM,UAAU,GAClB,uBAAuB,GACvB,qBAAqB,GACrB,iBAAiB,GACjB,wBAAwB,GACxB,cAAc,GACd,WAAW,GACX,QAAQ,GACR,UAAU,GACV,KAAK,GACL,UAAU,GACV,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;AAiQD,eAAO,MAAM,kBAAkB,EAAE,SAAS,kBAAkB,EAe3D,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/dist/services/local-inference/providers.js

@@ -0,0 +1,306 @@
+/**
+ * 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 { deviceBridge } from "./device-bridge.js";
+import { getDflashRuntimeStatus } from "./dflash-server.js";
+import { handlerRegistry } from "./handler-registry.js";
+import { localInferenceRoot } from "./paths.js";
+/** 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: "eliza-local-inference",
+    label: "Local llama.cpp",
+    kind: "local",
+    description: "On-device inference using node-llama-cpp, with DFlash llama-server acceleration when the managed binary and drafter companion are installed.",
+    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"));
+            if (!hasModel)
+                return { enabled: false, reason: "No local model installed" };
+            const dflash = getDflashRuntimeStatus();
+            return dflash.enabled
+                ? { enabled: true, reason: "GGUF model installed; DFlash available" }
+                : { enabled: true, reason: "GGUF model installed" };
+        }
+        catch {
+            return { enabled: false, reason: "No local model installed" };
+        }
+    },
+    configureHref: "#local-inference-panel",
+};
+const DEVICE_BRIDGE_PROVIDER = {
+    id: "eliza-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"],
+    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"],
+    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: "Eliza-hosted inference routed through your subscription. No API key to manage.",
+    supportedSlots: ["TEXT_SMALL", "TEXT_LARGE", "TEXT_EMBEDDING"],
+    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 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"],
+    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"],
+    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"],
+    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",
+};
+const DEEPSEEK_PROVIDER = {
+    id: "deepseek",
+    label: "DeepSeek API",
+    kind: "cloud-api",
+    description: "DeepSeek models via API key or linked account pool.",
+    supportedSlots: ["TEXT_SMALL", "TEXT_LARGE"],
+    async getEnableState() {
+        return apiKeyOrLinkedAccountState("deepseek-api", ["DEEPSEEK_API_KEY"]);
+    },
+    configureHref: "#ai-model",
+};
+const ZAI_PROVIDER = {
+    id: "zai",
+    label: "z.ai API",
+    kind: "cloud-api",
+    description: "GLM models via z.ai API key or linked account pool.",
+    supportedSlots: ["TEXT_SMALL", "TEXT_LARGE"],
+    async getEnableState() {
+        return apiKeyOrLinkedAccountState("zai-api", [
+            "ZAI_API_KEY",
+            "Z_AI_API_KEY",
+        ]);
+    },
+    configureHref: "#ai-model",
+};
+const MOONSHOT_PROVIDER = {
+    id: "moonshot",
+    label: "Kimi / Moonshot API",
+    kind: "cloud-api",
+    description: "Kimi models via Moonshot API key or linked account pool.",
+    supportedSlots: ["TEXT_SMALL", "TEXT_LARGE"],
+    async getEnableState() {
+        return apiKeyOrLinkedAccountState("moonshot-api", [
+            "MOONSHOT_API_KEY",
+            "KIMI_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,
+    DEEPSEEK_PROVIDER,
+    ZAI_PROVIDER,
+    MOONSHOT_PROVIDER,
+    GOOGLE_PROVIDER,
+    GROK_PROVIDER,
+    MISTRAL_PROVIDER,
+];
+function apiKeyOrLinkedAccountState(_providerId, envKeys) {
+    const hasEnv = envKeys.some((key) => process.env[key]?.trim());
+    if (hasEnv)
+        return { enabled: true, reason: "API key set" };
+    return { enabled: false, reason: "No API key or linked account" };
+}
+function subscriptionEnableState(providerId) {
+    if (providerId !== "anthropic-subscription" &&
+        providerId !== "openai-codex") {
+        return { enabled: false, reason: "Unsupported subscription" };
+    }
+    return { enabled: false, reason: "No linked account" };
+}
+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/dist/services/local-inference/readiness.d.ts

@@ -0,0 +1,9 @@
+import type { ActiveModelState, CatalogModel, DownloadJob, InstalledModel, LocalInferenceReadiness, ModelAssignments } from "./types";
+export declare function buildTextGenerationReadiness(input: {
+    assignments: ModelAssignments;
+    installed: InstalledModel[];
+    active: ActiveModelState;
+    downloads: DownloadJob[];
+    catalog?: CatalogModel[];
+}): LocalInferenceReadiness;
+//# sourceMappingURL=readiness.d.ts.map

package/dist/services/local-inference/readiness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readiness.d.ts","sourceRoot":"","sources":["../../../../../../src/services/local-inference/readiness.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,gBAAgB,EAChB,YAAY,EACZ,WAAW,EAEX,cAAc,EAEd,uBAAuB,EAEvB,gBAAgB,EAEjB,MAAM,SAAS,CAAC;AA8LjB,wBAAgB,4BAA4B,CAAC,KAAK,EAAE;IAClD,WAAW,EAAE,gBAAgB,CAAC;IAC9B,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B,MAAM,EAAE,gBAAgB,CAAC;IACzB,SAAS,EAAE,WAAW,EAAE,CAAC;IACzB,OAAO,CAAC,EAAE,YAAY,EAAE,CAAC;CAC1B,GAAG,uBAAuB,CA4B1B"}