@elizaos/plugin-local-inference 2.0.0-beta.1 → 2.0.11-beta.7

package/src/services/active-model-switch-rollback.test.ts

@@ -0,0 +1,183 @@
+import type { AgentRuntime } from "@elizaos/core";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+	ActiveModelCoordinator,
+	type LocalInferenceLoadArgs,
+	type LocalInferenceLoader,
+} from "./active-model";
+import type { HardwareProbe, InstalledModel } from "./types";
+
+function makeInstalledModel(id: string): InstalledModel {
+	return {
+		id,
+		displayName: id,
+		// `external-scan` ids are absent from MODEL_CATALOG, so
+		// assertModelFitsHost short-circuits and switchTo() exercises the
+		// loader path without needing on-disk weights.
+		path: `/tmp/${id}.gguf`,
+		sizeBytes: 1024,
+		installedAt: "2026-05-15T00:00:00.000Z",
+		lastUsedAt: null,
+		source: "external-scan",
+	};
+}
+
+const PROBE: HardwareProbe = {
+	totalRamGb: 64,
+	freeRamGb: 48,
+	gpu: null,
+	cpuCores: 8,
+	platform: "linux",
+	arch: "x64",
+	appleSilicon: false,
+	recommendedBucket: "mid",
+	source: "os-fallback",
+};
+
+/**
+ * Fake loader satisfying `isLoader` (loadModel/unloadModel/currentModelPath).
+ * `loadModel` rejects when `failNext` is set so we can simulate a load failure
+ * mid-switch without touching the real engine.
+ */
+class FakeLoader implements LocalInferenceLoader {
+	loaded: string | null = null;
+	failNextPaths = new Set<string>();
+	readonly loadCalls: string[] = [];
+	readonly unloadCalls: number[] = [];
+
+	async loadModel(args: LocalInferenceLoadArgs): Promise<void> {
+		this.loadCalls.push(args.modelPath);
+		if (this.failNextPaths.has(args.modelPath)) {
+			throw new Error(`simulated load failure for ${args.modelPath}`);
+		}
+		this.loaded = args.modelPath;
+	}
+
+	async unloadModel(): Promise<void> {
+		this.unloadCalls.push(this.unloadCalls.length);
+		this.loaded = null;
+	}
+
+	currentModelPath(): string | null {
+		return this.loaded;
+	}
+}
+
+function makeRuntime(loader: LocalInferenceLoader): AgentRuntime {
+	return {
+		agentId: "agent-test",
+		getService: (name: string) =>
+			name === "localInferenceLoader" ? loader : null,
+	} as unknown as AgentRuntime;
+}
+
+describe("ActiveModelCoordinator switchTo rollback (#13)", () => {
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	it("restores the previously-active model when a switch fails to load", async () => {
+		const loader = new FakeLoader();
+		const runtime = makeRuntime(loader);
+		const coordinator = new ActiveModelCoordinator();
+		const modelA = makeInstalledModel("model-a");
+		const modelB = makeInstalledModel("model-b");
+
+		// First load succeeds → A is the active, known-good model.
+		const first = await coordinator.switchTo(runtime, modelA, undefined, {
+			hardware: PROBE,
+		});
+		expect(first).toMatchObject({ modelId: "model-a", status: "ready" });
+		expect(loader.currentModelPath()).toBe(modelA.path);
+
+		// Switching to B fails to load. The old model must be restored, not lost.
+		loader.failNextPaths.add(modelB.path);
+		const second = await coordinator.switchTo(runtime, modelB, undefined, {
+			hardware: PROBE,
+		});
+
+		expect(second).toMatchObject({ modelId: "model-a", status: "ready" });
+		// A working model is loaded — NOT zero models, NOT an error attributed
+		// to the requested id.
+		expect(second.status).not.toBe("error");
+		expect(loader.currentModelPath()).toBe(modelA.path);
+	});
+
+	it("restores the same model when a reload with new overrides fails", async () => {
+		const loader = new FakeLoader();
+		const runtime = makeRuntime(loader);
+		const coordinator = new ActiveModelCoordinator();
+		const modelA = makeInstalledModel("model-a");
+
+		await coordinator.switchTo(
+			runtime,
+			modelA,
+			{ contextSize: 4096 },
+			{
+				hardware: PROBE,
+			},
+		);
+		expect(loader.currentModelPath()).toBe(modelA.path);
+
+		let loadCount = 0;
+		const originalLoad = loader.loadModel.bind(loader);
+		vi.spyOn(loader, "loadModel").mockImplementation(async (args) => {
+			loadCount += 1;
+			if (loadCount === 1) {
+				throw new Error("simulated same-model reload failure");
+			}
+			await originalLoad(args);
+		});
+
+		const state = await coordinator.switchTo(
+			runtime,
+			modelA,
+			{ contextSize: 8192 },
+			{ hardware: PROBE },
+		);
+
+		expect(state).toMatchObject({ modelId: "model-a", status: "ready" });
+		expect(loader.currentModelPath()).toBe(modelA.path);
+		expect(loader.loadModel).toHaveBeenCalledTimes(2);
+	});
+
+	it("reports no model loaded (modelId null, error) when no prior model existed", async () => {
+		const loader = new FakeLoader();
+		const runtime = makeRuntime(loader);
+		const coordinator = new ActiveModelCoordinator();
+		const modelA = makeInstalledModel("model-a");
+
+		loader.failNextPaths.add(modelA.path);
+		const state = await coordinator.switchTo(runtime, modelA, undefined, {
+			hardware: PROBE,
+		});
+
+		expect(state.status).toBe("error");
+		// Honest: nothing is loaded, so the id is null rather than a phantom
+		// "model-a" that callers would treat as a live model.
+		expect(state.modelId).toBeNull();
+		expect(loader.currentModelPath()).toBeNull();
+	});
+
+	it("reports no model loaded when both the switch and the restore fail", async () => {
+		const loader = new FakeLoader();
+		const runtime = makeRuntime(loader);
+		const coordinator = new ActiveModelCoordinator();
+		const modelA = makeInstalledModel("model-a");
+		const modelB = makeInstalledModel("model-b");
+
+		await coordinator.switchTo(runtime, modelA, undefined, {
+			hardware: PROBE,
+		});
+
+		// Both the new load AND the restore of the old model fail.
+		loader.failNextPaths.add(modelB.path);
+		loader.failNextPaths.add(modelA.path);
+		const state = await coordinator.switchTo(runtime, modelB, undefined, {
+			hardware: PROBE,
+		});
+
+		expect(state.status).toBe("error");
+		expect(state.modelId).toBeNull();
+	});
+});

package/src/services/active-model.d.ts

@@ -0,0 +1,282 @@
+/**
+ * Coordinates which model is currently loaded into the plugin-local-ai
+ * runtime. Eliza runs one inference model at a time; switching models
+ * unloads the previous one first so we don't double-allocate VRAM.
+ *
+ * This module *does not* talk to `capacitor-llama` directly. The plugin
+ * owns the native binding; we ask it to swap via a small runtime service
+ * registered under the name "localInferenceLoader". When the plugin is not
+ * enabled, we still track the user's preferred active model so the
+ * preference survives enabling the plugin later.
+ */
+import type { AgentRuntime } from "@elizaos/core";
+import { ELIZA_1_PLACEHOLDER_IDS, FIRST_RUN_DEFAULT_MODEL_ID } from "./catalog";
+import { type ManifestLoader, type RamFitOptions } from "./ram-budget";
+import { recommendForFirstRun } from "./recommendation";
+import type { ActiveModelState, CatalogModel, HardwareProbe, InstalledModel } from "./types";
+export type { KvOffloadMode, LocalInferenceLoadArgs } from "./load-args.js";
+export { ELIZA_1_PLACEHOLDER_IDS, FIRST_RUN_DEFAULT_MODEL_ID, recommendForFirstRun, };
+import type { KvOffloadMode, LocalInferenceLoadArgs } from "./load-args.js";
+export declare function isForkOnlyKvCacheType(name: string | undefined): boolean;
+export declare function isStockKvCacheType(name: string | undefined): boolean;
+/**
+ * Validate per-load overrides against what the in-process backend can
+ * honour. The AOSP loader has its own (broader) acceptance set — pass
+ * `{ allowFork: true }` to skip the desktop-only restriction.
+ *
+ * Throws on the first illegal value so the caller (the API route) can
+ * surface a 400 with a useful message instead of letting the load slip
+ * through and silently degrade to fp16.
+ */
+export declare function validateLocalInferenceLoadArgs(args: Partial<LocalInferenceLoadArgs>, options?: {
+    allowFork?: boolean;
+}): void;
+export interface LocalInferenceLoader {
+    loadModel(args: LocalInferenceLoadArgs): Promise<void>;
+    unloadModel(): Promise<void>;
+    currentModelPath(): string | null;
+    /**
+     * Optional generation surface. When a loader implements this, the runtime
+     * handler (`ensure-local-inference-handler.ts`) routes TEXT_SMALL /
+     * TEXT_LARGE requests through it instead of the standalone engine. Mobile
+     * builds populate this via the Capacitor adapter; desktop omits it and falls
+     * back to the `LocalInferenceEngine`.
+     */
+    generate?(args: {
+        prompt: string;
+        stopSequences?: string[];
+        maxTokens?: number;
+        temperature?: number;
+        /**
+         * Optional `promptCacheKey` from the runtime cache plan. Loaders
+         * that implement prefix caching (the in-process llama.cpp FFI slot
+         * pool or node-llama-cpp session pool) use this to pin
+         * subsequent calls with the same key to the same KV cache slot.
+         * Loaders without prefix caching can ignore the field.
+         */
+        cacheKey?: string;
+    }): Promise<string>;
+    /**
+     * Optional embedding surface. When a loader implements this, the runtime
+     * handler routes `TEXT_EMBEDDING` requests through it. The AOSP bun:ffi
+     * loader populates this directly via `llama_get_embeddings_seq`; the
+     * device-bridge loader populates it by dispatching an `embed` frame to
+     * the connected device. Loaders that cannot embed leave this undefined,
+     * and the runtime falls back to its non-local embedding provider chain.
+     */
+    embed?(args: {
+        input: string;
+    }): Promise<{
+        embedding: number[];
+        tokens: number;
+    }>;
+}
+/**
+ * Per-load override fields the caller can set. Subset of `LocalInferenceLoadArgs`
+ * minus `modelPath` (which the coordinator owns) and minus speculative
+ * fields (which the catalog `runtime.mtp` block owns end-to-end). The
+ * route layer accepts this shape on `POST /api/local-inference/active`.
+ */
+export interface LocalInferenceLoadOverrides {
+    contextSize?: number;
+    cacheTypeK?: string;
+    cacheTypeV?: string;
+    gpuLayers?: number;
+    kvOffload?: KvOffloadMode;
+    flashAttention?: boolean;
+    mmap?: boolean;
+    mlock?: boolean;
+    useGpu?: boolean;
+    maxThreads?: number;
+}
+interface ResolveLocalInferenceLoadArgsOptions {
+    manifestLoader?: ManifestLoader;
+}
+/**
+ * Resolve the per-tier mmproj GGUF path for a given installed model when
+ * the catalog declares the tier ships a vision projector AND the file is
+ * actually on disk under the bundle root.
+ *
+ * Returns:
+ *   - the absolute path to the mmproj file when the tier has vision and
+ *     the file exists.
+ *   - undefined when the tier has no vision component (text-only bundle)
+ *     or when the file hasn't been downloaded yet. In the latter case
+ *     the coordinator emits a one-shot warning; vision capability is
+ *     unavailable for the session but the text load still succeeds.
+ *
+ * Path layout: the catalog's `sourceModel.components.vision.file` is the
+ * Hugging Face-relative path, e.g. `bundles/2b/vision/mmproj-2b.gguf`.
+ * Locally the bundleRoot already represents the per-tier "bundles/<tier>"
+ * subtree, so we strip the leading `bundles/<tier>/` segment before
+ * joining against the local bundleRoot. When that prefix isn't present
+ * (e.g. a custom bundle layout), we fall through to the original path
+ * unchanged. Manifest-validated bundles (`bundleRoot` set) are the only
+ * path that lands a vision component — external-scan models (LM Studio,
+ * Jan) don't.
+ */
+export declare function resolveMmprojPath(installed: InstalledModel, catalog: CatalogModel | undefined): string | undefined;
+export declare function resolveLocalInferenceLoadArgs(installed: InstalledModel, overrides?: LocalInferenceLoadOverrides, options?: ResolveLocalInferenceLoadArgsOptions): Promise<LocalInferenceLoadArgs>;
+export declare class ModelDoesNotFitError extends Error {
+    readonly modelId: string;
+    readonly requiredMb: number;
+    readonly usableMb: number;
+    readonly hostRamMb: number;
+    readonly fittingVariantId: string | null;
+    constructor(args: {
+        modelId: string;
+        requiredMb: number;
+        usableMb: number;
+        hostRamMb: number;
+        fittingVariantId: string | null;
+    });
+}
+/**
+ * Admission gate: refuse a model load when the host can't fit the bundle's
+ * boot floor. `hostRamMb` is the host's total RAM in megabytes. `installed`
+ * is forwarded to `assessRamFit` so a manifest-declared `ramBudgetMb` wins
+ * over the catalog scalar. Throws `ModelDoesNotFitError` on no-fit; returns
+ * the (advisory) fit decision otherwise so callers can log a `tight` warning.
+ *
+ * Models with no catalog entry (external HF blobs) are not gated — the
+ * catalog has no RAM budget for them, so we trust the operator's explicit
+ * pick (the dispatcher's load-time error surfaces if it genuinely OOMs).
+ */
+export declare function assertModelFitsHost(installed: InstalledModel, hostRamMb: number, options?: RamFitOptions): {
+    level: "fits" | "tight";
+    minMb: number;
+    recommendedMb: number;
+};
+/**
+ * Typed error for refused local-voice sessions. Mirrors
+ * `ModelDoesNotFitError` but at the bundle level — emitted by
+ * `assertVoiceBundleFitsHost` when the whole co-resident voice + text stack
+ * cannot fit a host's RAM (per R9 §2.3 / §3.2).
+ *
+ * Catch this at the runtime's voice-session-start boundary and surface the
+ * tier-warning copy (`TIER_WARNING_COPY[<tier>]`) — DO NOT load weights and
+ * watch `MemoryMonitor` evict mid-session.
+ */
+export declare class VoiceBundleDoesNotFitError extends Error {
+    readonly tierSlot: string;
+    readonly deviceTier: string;
+    readonly requiredPeakMb: number;
+    readonly requiredSteadyStateMb: number;
+    readonly usableMb: number;
+    readonly hostRamMb: number;
+    constructor(args: {
+        tierSlot: string;
+        deviceTier: string;
+        requiredPeakMb: number;
+        requiredSteadyStateMb: number;
+        usableMb: number;
+        hostRamMb: number;
+    });
+}
+/**
+ * Cross-model admission gate for the local-voice session. Sums the whole
+ * co-resident bundle (LM + ASR + TTS + embedding + VAD +
+ * wake-word + turn-detector + emotion + speaker-encoder + transient TTS
+ * peak) and refuses entry when the host can't fit it.
+ *
+ * Returns the decision on `fits`. Throws `VoiceBundleDoesNotFitError` when
+ * `wontfit` (when `strict=true`, the default), or just returns the
+ * `wontfit` decision when `strict=false` (the runtime then logs and
+ * degrades silently). Pair with `TIER_WARNING_COPY[deviceTier]` for
+ * user-facing UX.
+ *
+ * R9 §1.4 + §2.3 + §3.2 spec.
+ */
+export declare function assertVoiceBundleFitsHost(args: {
+    tierSlot: string;
+    deviceTier: string;
+    hostRamMb: number;
+    reserveMb?: number;
+    strict?: boolean;
+}): {
+    level: "fits" | "tight" | "wontfit";
+    steadyStateMb: number;
+    peakMb: number;
+    usableMb: number;
+    fits: boolean;
+};
+/**
+ * Refusal raised when activation is asked for a model whose own
+ * `eliza-1.manifest.json` says its text eval has not passed (`candidate.*` /
+ * `weights-staged.*` tiers). Carries the structured payload the route layer
+ * surfaces verbatim to the API consumer: `manifestVersion` so the UI can
+ * say "this tier isn't ready" with the actual version string, and
+ * `failedEvals` so the user sees which checks are still red.
+ *
+ * Why we gate here, not just at download:
+ * - the bundle may already be on disk (hand-staged, manually copied, or
+ *   downloaded before a fail-state was recorded), so the download gate
+ *   alone leaves a window where a candidate-only bundle can be flipped
+ *   into the active model slot and silently emit `[unused]` tokens.
+ *
+ * See issue #7679 for the original symptom: the runtime activated an
+ * `eliza-1-0_8b` `1.0.0-candidate.1` bundle whose every `evals.*.passed`
+ * was `false`, then served BERT/WordPiece reserved tokens (`[unused0..99]`
+ * / `[PAD]`) as chat output with no actionable error.
+ */
+export declare class CandidateModelActivationError extends Error {
+    readonly modelId: string;
+    readonly manifestVersion: string;
+    readonly failedEvals: ReadonlyArray<string>;
+    constructor(args: {
+        modelId: string;
+        manifestVersion: string;
+        failedEvals: ReadonlyArray<string>;
+    });
+}
+/**
+ * Activation eval gate. Reads the installed bundle's manifest and refuses
+ * activation when `evals.textEval.passed` is not `true`. A bundle with no
+ * `eliza-1.manifest.json` on disk (third-party HF GGUFs, external scans,
+ * pre-bundle installs) is *not* gated — the gate only applies to bundles
+ * that ship a published manifest, which is the source of truth for the
+ * publish state.
+ *
+ * Throws `CandidateModelActivationError` on a failing manifest; returns
+ * silently otherwise.
+ */
+export declare function assertManifestEvalsPassed(installed: InstalledModel, manifestLoader?: ManifestLoader): void;
+export declare class ActiveModelCoordinator {
+    private state;
+    /**
+     * The last model that successfully reached `status: "ready"`, plus the
+     * inputs needed to re-load it. switchTo() tears the active model down
+     * before loading the new one (unload-then-load); if the new load fails we
+     * restore this so a failed switch never leaves the host with zero models
+     * loaded while a working one existed moments earlier. `null` until the
+     * first successful load (or after an unload).
+     */
+    private lastReady;
+    private readonly listeners;
+    snapshot(): ActiveModelState;
+    subscribe(listener: (state: ActiveModelState) => void): () => void;
+    private emit;
+    /**
+     * WS2: one-shot warning latch per (modelId) — when the tier declares
+     * vision but no mmproj GGUF was found on disk, log once so the
+     * operator sees that vision is degraded for this session. The
+     * arbiter's vision-describe capability stays unregistered for this
+     * session; plugin-vision falls back to its non-eliza-1 path.
+     */
+    private readonly warnedDegradedVisionFor;
+    private warnIfVisionDegraded;
+    /** Return the loader service from the current runtime, if registered. */
+    private getLoader;
+    switchTo(runtime: AgentRuntime | null, installed: InstalledModel, overrides?: LocalInferenceLoadOverrides, opts?: {
+        hardware?: HardwareProbe;
+        manifestLoader?: ManifestLoader;
+    }): Promise<ActiveModelState>;
+    /**
+     * Run the unload-then-load against the loader (or standalone engine) and
+     * build the `status: "ready"` state. Throws on any load failure; never
+     * mutates `this.state`/`this.lastReady` so callers control rollback.
+     */
+    private performLoad;
+    unload(runtime: AgentRuntime | null): Promise<ActiveModelState>;
+}
+//# sourceMappingURL=active-model.d.ts.map

package/src/services/active-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-model.d.ts","sourceRoot":"","sources":["active-model.ts"],"names":[],"mappings":"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"}