@elizaos/ui 2.0.0-beta.1 → 2.0.0-beta.2

package/{dist/services → services}/local-inference/catalog.js

@@ -5,10 +5,10 @@
  * default per device tier (`lite-0_6b`, `mobile-1_7b`, `desktop-9b`,
  * `pro-27b`, `server-h200`). The recommendation engine picks one of
  * these tiers based on hardware. See
- * `/Users/shawwalters/eliza-workspace/milady/packages/inference/AGENTS.md`
+ * `/Users/shawwalters/eliza-workspace/milady/eliza/packages/inference/AGENTS.md`
  * §2 for the binding tier matrix.
  *
- * HF-search results from outside `elizaos/eliza-1-*` MUST never be
+ * HF-search results from outside `elizalabs/eliza-1-*` MUST never be
  * marked default-eligible (handled by `hf-search.ts`, which produces
  * entries that are absent from `DEFAULT_ELIGIBLE_MODEL_IDS`).
  *
@@ -47,87 +47,203 @@ export function isDefaultEligibleId(id) {
 }
 /** Compatibility export for callers that need the Eliza-1 model id set. */
 export const ELIZA_1_PLACEHOLDER_IDS = new Set(ELIZA_1_TIER_IDS);
+const BASE_REQUIRED_KERNELS = [
+    "dflash",
+    "turbo3",
+    "turbo4",
+    "qjl_full",
+    "polarquant",
+];
+function requiredKernelsForContext(contextLength) {
+    return contextLength > 65536
+        ? [...BASE_REQUIRED_KERNELS, "turbo3_tcq"]
+        : [...BASE_REQUIRED_KERNELS];
+}
+function drafterId(id) {
+    return `${id}-drafter`;
+}
+function runtimeFor(id, contextLength) {
+    return {
+        preferredBackend: "llama-server",
+        optimizations: {
+            parallel: contextLength >= 131072 ? 8 : 4,
+            flashAttention: true,
+            mlock: contextLength >= 131072,
+            requiresKernel: requiredKernelsForContext(contextLength),
+        },
+        dflash: {
+            drafterModelId: drafterId(id),
+            specType: "dflash",
+            contextSize: contextLength,
+            draftContextSize: Math.min(contextLength, 65536),
+            draftMin: 2,
+            draftMax: contextLength >= 131072 ? 8 : 6,
+            gpuLayers: "auto",
+            draftGpuLayers: "auto",
+            disableThinking: true,
+        },
+    };
+}
+function drafterCompanion(args) {
+    return {
+        id: drafterId(args.id),
+        displayName: `${args.displayName} drafter`,
+        hfRepo: `elizalabs/${args.id}`,
+        ggufFile: args.ggufFile,
+        params: args.params,
+        quant: "Eliza-1 drafter companion",
+        sizeGb: args.sizeGb,
+        minRamGb: args.minRamGb,
+        category: "drafter",
+        bucket: args.bucket,
+        hiddenFromCatalog: true,
+        runtimeRole: "dflash-drafter",
+        companionForModelId: args.id,
+        tokenizerFamily: "eliza1",
+        blurb: `${args.displayName} drafter companion.`,
+    };
+}
 export const MODEL_CATALOG = [
     // ─── Eliza-1 lite (low-RAM phones, CPU fallback) ────────────────────
     {
         id: "eliza-1-lite-0_6b",
         displayName: "Eliza-1 lite",
-        hfRepo: "elizaos/eliza-1-lite-0_6b",
+        hfRepo: "elizalabs/eliza-1-lite-0_6b",
         ggufFile: "text/eliza-1-lite-0_6b-32k.gguf",
+        bundleManifestFile: "eliza-1.manifest.json",
         params: "1B",
-        quant: "TurboQuant Q3 + Polar Q4 KV",
+        quant: "Eliza-1 optimized local runtime",
         sizeGb: 0.5,
         minRamGb: 2,
         category: "chat",
         bucket: "small",
         contextLength: 32768,
         tokenizerFamily: "eliza1",
-        blurb: "Eliza-1 lite — fits low-RAM phones and CPU-only fallback. Fused text + voice bundle with TurboQuant Q3 + Polar KV.",
+        companionModelIds: ["eliza-1-lite-0_6b-drafter"],
+        runtime: runtimeFor("eliza-1-lite-0_6b", 32768),
+        blurb: "Eliza-1 lite — fits low-RAM phones and CPU-only fallback with the optimized local runtime.",
     },
+    drafterCompanion({
+        id: "eliza-1-lite-0_6b",
+        displayName: "Eliza-1 lite",
+        ggufFile: "dflash/drafter-lite-0_6b.gguf",
+        params: "1B",
+        sizeGb: 0.25,
+        minRamGb: 2,
+        bucket: "small",
+    }),
     // ─── Eliza-1 mobile (modern phones) ─────────────────────────────────
     {
         id: "eliza-1-mobile-1_7b",
         displayName: "Eliza-1 mobile",
-        hfRepo: "elizaos/eliza-1-mobile-1_7b",
+        hfRepo: "elizalabs/eliza-1-mobile-1_7b",
         ggufFile: "text/eliza-1-mobile-1_7b-32k.gguf",
+        bundleManifestFile: "eliza-1.manifest.json",
         params: "1.7B",
-        quant: "TurboQuant Q3/Q4 + QJL K-cache",
+        quant: "Eliza-1 optimized local runtime",
         sizeGb: 1.2,
         minRamGb: 4,
         category: "chat",
         bucket: "small",
         contextLength: 32768,
         tokenizerFamily: "eliza1",
-        blurb: "Eliza-1 mobile — modern phone default. Fused text + voice with TurboQuant Q3/Q4 and QJL K-cache.",
+        companionModelIds: ["eliza-1-mobile-1_7b-drafter"],
+        runtime: runtimeFor("eliza-1-mobile-1_7b", 32768),
+        blurb: "Eliza-1 mobile — modern phone default with text and voice prepared for the optimized local runtime.",
     },
+    drafterCompanion({
+        id: "eliza-1-mobile-1_7b",
+        displayName: "Eliza-1 mobile",
+        ggufFile: "dflash/drafter-mobile-1_7b.gguf",
+        params: "1.7B",
+        sizeGb: 0.35,
+        minRamGb: 4,
+        bucket: "small",
+    }),
     // ─── Eliza-1 desktop (laptops, 24GB phones, 48GB Mac) ───────────────
     {
         id: "eliza-1-desktop-9b",
         displayName: "Eliza-1 desktop",
-        hfRepo: "elizaos/eliza-1-desktop-9b",
+        hfRepo: "elizalabs/eliza-1-desktop-9b",
         ggufFile: "text/eliza-1-desktop-9b-64k.gguf",
+        bundleManifestFile: "eliza-1.manifest.json",
         params: "9B",
-        quant: "TurboQuant Q4 + QJL + Polar",
+        quant: "Eliza-1 optimized local runtime",
         sizeGb: 5.4,
         minRamGb: 12,
         category: "chat",
         bucket: "mid",
         contextLength: 65536,
         tokenizerFamily: "eliza1",
-        blurb: "Eliza-1 desktop — laptop / 24 GB phone / 48 GB Mac default. Fused text + voice + vision with TurboQuant Q4, QJL, PolarQuant.",
+        companionModelIds: ["eliza-1-desktop-9b-drafter"],
+        runtime: runtimeFor("eliza-1-desktop-9b", 65536),
+        blurb: "Eliza-1 desktop — laptop / 24 GB phone / 48 GB Mac default with text, voice, and vision in the optimized local runtime.",
     },
+    drafterCompanion({
+        id: "eliza-1-desktop-9b",
+        displayName: "Eliza-1 desktop",
+        ggufFile: "dflash/drafter-desktop-9b.gguf",
+        params: "9B",
+        sizeGb: 0.8,
+        minRamGb: 12,
+        bucket: "mid",
+    }),
     // ─── Eliza-1 pro (96GB+ Mac, high-VRAM desktop) ─────────────────────
     {
         id: "eliza-1-pro-27b",
         displayName: "Eliza-1 pro",
-        hfRepo: "elizaos/eliza-1-pro-27b",
+        hfRepo: "elizalabs/eliza-1-pro-27b",
         ggufFile: "text/eliza-1-pro-27b-128k.gguf",
+        bundleManifestFile: "eliza-1.manifest.json",
         params: "27B",
-        quant: "TurboQuant Q4 + QJL + Polar",
+        quant: "Eliza-1 optimized local runtime",
         sizeGb: 16.8,
         minRamGb: 32,
         category: "chat",
         bucket: "large",
         contextLength: 131072,
         tokenizerFamily: "eliza1",
+        companionModelIds: ["eliza-1-pro-27b-drafter"],
+        runtime: runtimeFor("eliza-1-pro-27b", 131072),
         blurb: "Eliza-1 pro — 96 GB+ Mac and high-VRAM desktop default. Fused text + voice + vision; longest-context Eliza-1 tier on workstation hardware.",
     },
+    drafterCompanion({
+        id: "eliza-1-pro-27b",
+        displayName: "Eliza-1 pro",
+        ggufFile: "dflash/drafter-pro-27b.gguf",
+        params: "9B",
+        sizeGb: 1.2,
+        minRamGb: 32,
+        bucket: "large",
+    }),
     // ─── Eliza-1 server (workstation / server) ──────────────────────────
     {
         id: "eliza-1-server-h200",
         displayName: "Eliza-1 server",
-        hfRepo: "elizaos/eliza-1-server-h200",
+        hfRepo: "elizalabs/eliza-1-server-h200",
         ggufFile: "text/eliza-1-server-h200-256k.gguf",
+        bundleManifestFile: "eliza-1.manifest.json",
         params: "27B",
-        quant: "CUDA TurboQuant + QJL + Polar",
+        quant: "Eliza-1 optimized local runtime",
         sizeGb: 16.8,
         minRamGb: 96,
         category: "chat",
         bucket: "large",
         contextLength: 262144,
         tokenizerFamily: "eliza1",
-        blurb: "Eliza-1 server — H200-class workstation / server. CUDA TurboQuant + QJL + Polar with the largest context window in the line.",
+        companionModelIds: ["eliza-1-server-h200-drafter"],
+        runtime: runtimeFor("eliza-1-server-h200", 262144),
+        blurb: "Eliza-1 server — H200-class workstation / server tier with the largest context window in the line.",
     },
+    drafterCompanion({
+        id: "eliza-1-server-h200",
+        displayName: "Eliza-1 server",
+        ggufFile: "dflash/drafter-server-h200.gguf",
+        params: "9B",
+        sizeGb: 1.2,
+        minRamGb: 96,
+        bucket: "large",
+    }),
 ];
 export function findCatalogModel(id) {
     return MODEL_CATALOG.find((m) => m.id === id);
@@ -139,14 +255,17 @@ export function findCatalogModel(id) {
  * downloader e2e test suite can redirect all downloads without touching
  * the catalog.
  */
-export function buildHuggingFaceResolveUrl(model) {
+export function buildHuggingFaceResolveUrlForPath(model, filePath) {
     const base = process.env.ELIZA_HF_BASE_URL?.trim().replace(/\/+$/, "") ||
         "https://huggingface.co";
     // Encode each path segment separately so nested bundle layouts like
     // `text/eliza-1-mobile-1_7b-32k.gguf` keep their slashes.
-    const encodedPath = model.ggufFile
+    const encodedPath = filePath
         .split("/")
         .map((segment) => encodeURIComponent(segment))
         .join("/");
     return `${base}/${model.hfRepo}/resolve/main/${encodedPath}?download=true`;
 }
+export function buildHuggingFaceResolveUrl(model) {
+    return buildHuggingFaceResolveUrlForPath(model, model.ggufFile);
+}

package/{dist/services → services}/local-inference/downloader.d.ts

@@ -40,6 +40,8 @@ export declare class Downloader {
     private clearTerminalDownload;
     private throttleEmit;
     private runJob;
+    private runBundleJob;
+    private downloadRemotePath;
     private loadHttpClient;
 }
 export {};

package/{dist/services → services}/local-inference/downloader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"downloader.d.ts","sourceRoot":"","sources":["../../../../../../src/services/local-inference/downloader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAgBH,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,WAAW,EAGZ,MAAM,SAAS,CAAC;AAUjB,KAAK,gBAAgB,GAAG,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;AAwDvD,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgC;IACvD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkC;IAC3D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA+B;IACzD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6B;;IAMtD,SAAS,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,IAAI;IAOjD,QAAQ,IAAI,WAAW,EAAE;IAUzB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAQlC;;;;OAIG;IACG,KAAK,CAAC,aAAa,EAAE,MAAM,GAAG,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC;IA2DvE,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAchC,OAAO,CAAC,IAAI;IAWZ,OAAO,CAAC,WAAW;IAKnB,OAAO,CAAC,qBAAqB;IAwB7B,OAAO,CAAC,wBAAwB;IAkBhC,OAAO,CAAC,wBAAwB;IAYhC,OAAO,CAAC,qBAAqB;IAK7B,OAAO,CAAC,YAAY;YAQN,MAAM;YAwJN,cAAc;CAkC7B"}
+{"version":3,"file":"downloader.d.ts","sourceRoot":"","sources":["../../../../../../src/services/local-inference/downloader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAoBH,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,WAAW,EAGZ,MAAM,SAAS,CAAC;AAUjB,KAAK,gBAAgB,GAAG,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;AAsPvD,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgC;IACvD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkC;IAC3D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA+B;IACzD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6B;;IAMtD,SAAS,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,IAAI;IAOjD,QAAQ,IAAI,WAAW,EAAE;IAUzB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAQlC;;;;OAIG;IACG,KAAK,CAAC,aAAa,EAAE,MAAM,GAAG,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC;IA2DvE,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAchC,OAAO,CAAC,IAAI;IAWZ,OAAO,CAAC,WAAW;IAKnB,OAAO,CAAC,qBAAqB;IAwB7B,OAAO,CAAC,wBAAwB;IAkBhC,OAAO,CAAC,wBAAwB;IAYhC,OAAO,CAAC,qBAAqB;IAK7B,OAAO,CAAC,YAAY;YAQN,MAAM;YAgKN,YAAY;YAgJZ,kBAAkB;YAiHlB,cAAc;CAkC7B"}

package/{dist/services → services}/local-inference/downloader.js

@@ -21,7 +21,7 @@ import path from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { ensureDefaultAssignment } from "./assignments.js";
-import { buildHuggingFaceResolveUrl, findCatalogModel } from "./catalog.js";
+import { buildHuggingFaceResolveUrl, buildHuggingFaceResolveUrlForPath, findCatalogModel, } from "./catalog.js";
 import { downloadsStagingDir, elizaModelsDir, localInferenceRoot, } from "./paths.js";
 import { upsertElizaModel } from "./registry.js";
 import { hashFile } from "./verify.js";
@@ -53,6 +53,126 @@ function finalFilename(model) {
     const safe = model.id.replace(/[^a-zA-Z0-9._-]/g, "_");
     return `${safe}.gguf`;
 }
+function bundleDirname(modelId) {
+    const safe = modelId.replace(/[^a-zA-Z0-9._-]/g, "_");
+    return `${safe}.bundle`;
+}
+function bundleStagingFilename(modelId, filePath) {
+    const safePath = filePath.replace(/[^a-zA-Z0-9._-]/g, "_");
+    return stagingFilename(`${modelId}__${safePath}`);
+}
+function bundleTargetPath(root, filePath) {
+    if (!filePath ||
+        path.isAbsolute(filePath) ||
+        /^[a-zA-Z]:[\\/]/.test(filePath)) {
+        throw new Error(`Invalid bundle file path: ${filePath}`);
+    }
+    const resolvedRoot = path.resolve(root);
+    const target = path.resolve(resolvedRoot, filePath);
+    if (target !== resolvedRoot &&
+        !target.startsWith(`${resolvedRoot}${path.sep}`)) {
+        throw new Error(`Bundle file escapes install root: ${filePath}`);
+    }
+    return target;
+}
+function parseBundleFileEntry(value, kind) {
+    if (!value || typeof value !== "object") {
+        throw new Error(`Invalid Eliza-1 manifest file entry in files.${kind}`);
+    }
+    const entry = value;
+    if (typeof entry.path !== "string" || entry.path.length === 0) {
+        throw new Error(`Invalid Eliza-1 manifest file path in files.${kind}`);
+    }
+    if (typeof entry.sha256 !== "string" ||
+        !/^[a-f0-9]{64}$/.test(entry.sha256)) {
+        throw new Error(`Invalid Eliza-1 manifest sha256 for ${entry.path}`);
+    }
+    const parsed = {
+        path: entry.path,
+        sha256: entry.sha256,
+    };
+    if (typeof entry.ctx === "number")
+        parsed.ctx = entry.ctx;
+    return parsed;
+}
+function parseBundleManifestOrThrow(input, catalogEntry) {
+    if (!input || typeof input !== "object") {
+        throw new Error("Invalid Eliza-1 manifest: expected object");
+    }
+    const raw = input;
+    if (raw.id !== catalogEntry.id) {
+        throw new Error(`Invalid Eliza-1 manifest: id ${String(raw.id)} does not match ${catalogEntry.id}`);
+    }
+    if (typeof raw.version !== "string" || raw.version.length === 0) {
+        throw new Error("Invalid Eliza-1 manifest: missing version");
+    }
+    if (raw.defaultEligible !== true) {
+        throw new Error("Invalid Eliza-1 manifest: defaultEligible must be true");
+    }
+    if (!raw.files || typeof raw.files !== "object") {
+        throw new Error("Invalid Eliza-1 manifest: missing files");
+    }
+    const filesRaw = raw.files;
+    const files = {};
+    for (const kind of [
+        "text",
+        "voice",
+        "asr",
+        "vision",
+        "dflash",
+        "cache",
+        "embedding",
+        "vad",
+        "wakeword",
+    ]) {
+        const value = filesRaw[kind];
+        if (value === undefined &&
+            (kind === "embedding" || kind === "vad" || kind === "wakeword")) {
+            files[kind] = [];
+            continue;
+        }
+        if (!Array.isArray(value)) {
+            throw new Error(`Invalid Eliza-1 manifest: files.${kind} must be an array`);
+        }
+        files[kind] = value.map((entry) => parseBundleFileEntry(entry, kind));
+    }
+    for (const kind of ["text", "voice", "dflash", "cache"]) {
+        if (files[kind].length === 0) {
+            throw new Error(`Invalid Eliza-1 manifest: files.${kind} must be non-empty`);
+        }
+    }
+    if (!files.text.some((entry) => entry.path === catalogEntry.ggufFile)) {
+        throw new Error(`Invalid Eliza-1 manifest: primary text file ${catalogEntry.ggufFile} is missing`);
+    }
+    return {
+        id: catalogEntry.id,
+        version: raw.version,
+        files,
+    };
+}
+function collectBundleFiles(manifest) {
+    const seen = new Map();
+    for (const kind of [
+        "text",
+        "voice",
+        "asr",
+        "vision",
+        "dflash",
+        "cache",
+        "embedding",
+        "vad",
+        "wakeword",
+    ]) {
+        for (const entry of manifest.files[kind]) {
+            const current = seen.get(entry.path);
+            if (current && current.entry.sha256 !== entry.sha256) {
+                throw new Error(`Conflicting sha256 entries for bundle file ${entry.path}`);
+            }
+            seen.set(entry.path, { kind, entry });
+        }
+    }
+    return [...seen.values()];
+}
 async function ensureDirs() {
     await fsp.mkdir(downloadsStagingDir(), { recursive: true });
     await fsp.mkdir(elizaModelsDir(), { recursive: true });
@@ -236,6 +356,11 @@ export class Downloader {
     async runJob(catalogEntry, record) {
         try {
             this.updateState(record, "downloading");
+            if (catalogEntry.bundleManifestFile &&
+                catalogEntry.runtimeRole !== "dflash-drafter") {
+                await this.runBundleJob(catalogEntry, record);
+                return;
+            }
             const url = buildHuggingFaceResolveUrl(catalogEntry);
             const httpClient = await this.loadHttpClient();
             const startByte = record.job.received;
@@ -365,6 +490,180 @@ export class Downloader {
             this.active.delete(record.job.modelId);
         }
     }
+    async runBundleJob(catalogEntry, record) {
+        if (!catalogEntry.bundleManifestFile) {
+            throw new Error(`[local-inference] ${catalogEntry.id} has no bundle manifest`);
+        }
+        const bundleRoot = path.join(elizaModelsDir(), bundleDirname(catalogEntry.id));
+        await fsp.mkdir(bundleRoot, { recursive: true });
+        const manifestPath = bundleTargetPath(bundleRoot, catalogEntry.bundleManifestFile);
+        const manifestDownloaded = await this.downloadRemotePath(catalogEntry, catalogEntry.bundleManifestFile, path.join(downloadsStagingDir(), bundleStagingFilename(catalogEntry.id, catalogEntry.bundleManifestFile)), manifestPath, record, 0);
+        const manifest = parseBundleManifestOrThrow(JSON.parse(await fsp.readFile(manifestPath, "utf8")), catalogEntry);
+        let completedBytes = manifestDownloaded.sizeBytes;
+        const downloaded = new Map();
+        for (const { entry } of collectBundleFiles(manifest)) {
+            const finalPath = bundleTargetPath(bundleRoot, entry.path);
+            const result = await this.downloadRemotePath(catalogEntry, entry.path, path.join(downloadsStagingDir(), bundleStagingFilename(catalogEntry.id, entry.path)), finalPath, record, completedBytes, entry.sha256);
+            downloaded.set(entry.path, result);
+            completedBytes += result.sizeBytes;
+            record.job.received = completedBytes;
+            record.job.total = Math.max(record.job.total, completedBytes);
+            this.throttleEmit(record);
+        }
+        const textEntry = manifest.files.text.find((entry) => entry.path === catalogEntry.ggufFile);
+        if (!textEntry) {
+            throw new Error(`[local-inference] Bundle missing primary text file ${catalogEntry.ggufFile}`);
+        }
+        const textFile = downloaded.get(textEntry.path);
+        if (!textFile) {
+            throw new Error(`[local-inference] Bundle did not install text file ${textEntry.path}`);
+        }
+        const now = new Date().toISOString();
+        const bundleMeta = {
+            bundleRoot,
+            manifestPath,
+            manifestSha256: manifestDownloaded.sha256,
+            bundleVersion: manifest.version,
+            bundleSizeBytes: completedBytes,
+        };
+        const installed = {
+            id: catalogEntry.id,
+            displayName: catalogEntry.displayName,
+            path: textFile.path,
+            sizeBytes: textFile.sizeBytes,
+            hfRepo: catalogEntry.hfRepo,
+            installedAt: now,
+            lastUsedAt: null,
+            source: "eliza-download",
+            sha256: textFile.sha256,
+            lastVerifiedAt: now,
+            ...bundleMeta,
+        };
+        await upsertElizaModel(installed);
+        const companionId = catalogEntry.runtime?.dflash?.drafterModelId ??
+            catalogEntry.companionModelIds?.[0];
+        const companion = companionId ? findCatalogModel(companionId) : undefined;
+        if (companion) {
+            const drafterEntry = manifest.files.dflash.find((entry) => entry.path === companion.ggufFile);
+            if (!drafterEntry) {
+                throw new Error(`[local-inference] Bundle missing DFlash companion ${companion.ggufFile}`);
+            }
+            const drafterFile = downloaded.get(drafterEntry.path);
+            if (!drafterFile) {
+                throw new Error(`[local-inference] Bundle did not install DFlash companion ${drafterEntry.path}`);
+            }
+            await upsertElizaModel({
+                id: companion.id,
+                displayName: companion.displayName,
+                path: drafterFile.path,
+                sizeBytes: drafterFile.sizeBytes,
+                hfRepo: companion.hfRepo,
+                installedAt: now,
+                lastUsedAt: null,
+                source: "eliza-download",
+                sha256: drafterFile.sha256,
+                lastVerifiedAt: now,
+                runtimeRole: "dflash-drafter",
+                companionFor: catalogEntry.id,
+                ...bundleMeta,
+            });
+        }
+        await ensureDefaultAssignment(installed.id);
+        this.updateState(record, "completed");
+        record.job.received = completedBytes;
+        record.job.total = completedBytes;
+        this.rememberTerminalDownload(record.job);
+        this.emit({ type: "completed", job: { ...record.job } });
+    }
+    async downloadRemotePath(catalogEntry, remotePath, stagingPath, finalPath, record, baseBytes, expectedSha256) {
+        if (expectedSha256) {
+            try {
+                const stat = await fsp.stat(finalPath);
+                if (stat.isFile()) {
+                    const currentSha256 = await hashFile(finalPath);
+                    if (currentSha256 === expectedSha256) {
+                        record.job.received = baseBytes + stat.size;
+                        return {
+                            path: finalPath,
+                            sizeBytes: stat.size,
+                            sha256: currentSha256,
+                        };
+                    }
+                    await fsp.rm(finalPath, { force: true });
+                }
+            }
+            catch {
+                // Missing files are downloaded below; unreadable stale files are
+                // treated as invalid and replaced by the fresh bundle artifact.
+            }
+        }
+        else {
+            await fsp.rm(stagingPath, { force: true }).catch(() => undefined);
+        }
+        await fsp.mkdir(path.dirname(finalPath), { recursive: true });
+        await fsp.mkdir(path.dirname(stagingPath), { recursive: true });
+        let startByte = expectedSha256 ? await partialSize(stagingPath) : 0;
+        record.job.received = baseBytes + startByte;
+        const headers = {
+            "user-agent": "Eliza-LocalInference/1.0",
+        };
+        if (startByte > 0) {
+            headers.range = `bytes=${startByte}-`;
+        }
+        const httpClient = await this.loadHttpClient();
+        const url = buildHuggingFaceResolveUrlForPath(catalogEntry, remotePath);
+        const response = await httpClient.request(url, {
+            method: "GET",
+            headers,
+            signal: record.abortController.signal,
+        });
+        if (response.statusCode >= 400) {
+            throw new Error(`HTTP ${response.statusCode} from HuggingFace for ${catalogEntry.hfRepo}/${remotePath}`);
+        }
+        if (startByte > 0 && response.statusCode !== 206) {
+            startByte = 0;
+            record.job.received = baseBytes;
+        }
+        const contentLengthHeader = response.headers["content-length"];
+        const contentLength = Array.isArray(contentLengthHeader)
+            ? Number.parseInt(contentLengthHeader[0] ?? "0", 10)
+            : Number.parseInt(contentLengthHeader ?? "0", 10);
+        if (Number.isFinite(contentLength) && contentLength > 0) {
+            record.job.total = Math.max(record.job.total, baseBytes + startByte + contentLength);
+        }
+        const writeStream = fs.createWriteStream(stagingPath, {
+            flags: startByte > 0 ? "a" : "w",
+        });
+        let lastSampleBytes = record.job.received;
+        let lastSampleAt = Date.now();
+        const bodyStream = Readable.from(response.body);
+        bodyStream.on("data", (chunk) => {
+            record.job.received += chunk.length;
+            const now = Date.now();
+            const elapsed = now - lastSampleAt;
+            if (elapsed >= 1000) {
+                record.job.bytesPerSec =
+                    ((record.job.received - lastSampleBytes) * 1000) / elapsed;
+                record.job.etaMs =
+                    record.job.bytesPerSec > 0
+                        ? ((record.job.total - record.job.received) * 1000) /
+                            record.job.bytesPerSec
+                        : null;
+                lastSampleAt = now;
+                lastSampleBytes = record.job.received;
+            }
+            this.throttleEmit(record);
+        });
+        await pipeline(bodyStream, writeStream);
+        await fsp.rename(stagingPath, finalPath);
+        const stat = await fsp.stat(finalPath);
+        const sha256 = await hashFile(finalPath);
+        if (expectedSha256 && sha256 !== expectedSha256) {
+            await fsp.rm(finalPath, { force: true });
+            throw new Error(`SHA256 mismatch for bundle file ${remotePath}`);
+        }
+        return { path: finalPath, sizeBytes: stat.size, sha256 };
+    }
     async loadHttpClient() {
         const fetchImpl = globalThis.fetch;
         return {

package/{dist/services → services}/local-inference/providers.d.ts

@@ -2,7 +2,7 @@
  * Provider registry.
  *
  * Treats every inference source the same way — cloud subscription, cloud
- * API, local llama.cpp engine, paired-device bridge, Capacitor on-device
+ * API, Eliza-1 local runtime, 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

package/{dist/services → services}/local-inference/providers.js

@@ -2,7 +2,7 @@
  * Provider registry.
  *
  * Treats every inference source the same way — cloud subscription, cloud
- * API, local llama.cpp engine, paired-device bridge, Capacitor on-device
+ * API, Eliza-1 local runtime, 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
@@ -33,9 +33,9 @@ export function getRegisteredSlotsForProvider(providerId) {
 // ── Built-in provider definitions ────────────────────────────────────
 const LOCAL_PROVIDER = {
     id: "eliza-local-inference",
-    label: "Local llama.cpp",
+    label: "Eliza-1 local runtime",
     kind: "local",
-    description: "On-device inference using node-llama-cpp, with DFlash llama-server acceleration when the managed binary and drafter companion are installed.",
+    description: "On-device Eliza-1 inference with the optimized local runtime when the managed binary and companion files are installed.",
     supportedSlots: ["TEXT_SMALL", "TEXT_LARGE"],
     async getEnableState() {
         // Enabled when at least one model file lives under our root and the
@@ -50,7 +50,7 @@ const LOCAL_PROVIDER = {
                 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: "Eliza-1 model installed; local acceleration available" }
                 : { enabled: true, reason: "GGUF model installed" };
         }
         catch {
@@ -89,9 +89,9 @@ const DEVICE_BRIDGE_PROVIDER = {
 };
 const CAPACITOR_LLAMA_PROVIDER = {
     id: "capacitor-llama",
-    label: "On-device llama.cpp (mobile)",
+    label: "Eliza-1 mobile runtime",
     kind: "local",
-    description: "Runs llama.cpp natively on iOS or Android via Capacitor. Only available in mobile builds.",
+    description: "Runs Eliza-1 natively on iOS or Android via Capacitor. Only available in mobile builds.",
     supportedSlots: ["TEXT_SMALL", "TEXT_LARGE"],
     async getEnableState() {
         const cap = globalThis.Capacitor;

package/{dist/services → services}/local-inference/recommendation.js

@@ -55,7 +55,7 @@ function chatCandidates(catalog) {
     return catalog.filter((model) => !model.hiddenFromCatalog && model.runtimeRole !== "dflash-drafter");
 }
 export function classifyRecommendationPlatform(hardware) {
-    const platform = hardware.platform;
+    const platform = hardware.mobile?.platform ?? hardware.platform;
     if (platform === "android" || platform === "ios")
         return "mobile";
     if (hardware.appleSilicon)

package/{dist/services → services}/local-inference/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../../../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,wEAAwE;AACxE,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAe3E;AAED,gEAAgE;AAChE,wBAAsB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM/D;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1D,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,UAAU,GAAG,WAAW,CAAC;CACnC,CAAC,CAyBD"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../../../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,wEAAwE;AACxE,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAyB3E;AAED,gEAAgE;AAChE,wBAAsB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM/D;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1D,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,UAAU,GAAG,WAAW,CAAC;CACnC,CAAC,CA6BD"}