@elizaos/plugin-local-inference 2.0.3-beta.2 → 2.0.3-beta.4

package/src/services/routing-policy.test.ts

@@ -2,17 +2,22 @@ import type { IAgentRuntime } from "@elizaos/core";
 import { describe, expect, it } from "vitest";
 import { classifyDeviceTier, type DeviceTierAssessment } from "./device-tier";
 import type { HandlerRegistration } from "./handler-registry";
+import type { LiveDeviceSignals } from "./live-signals";
 import { policyEngine } from "./routing-policy";
-import type { HardwareProbe } from "./types";
+import type { AgentModelSlot, HardwareProbe } from "./types";
 
 const noopHandler: HandlerRegistration["handler"] = async (
 	_runtime: IAgentRuntime,
 	_params: Record<string, unknown>,
 ) => null;
 
-function registration(provider: string, priority: number): HandlerRegistration {
+function registration(
+	provider: string,
+	priority: number,
+	modelType = "TEXT_LARGE",
+): HandlerRegistration {
 	return {
-		modelType: "TEXT_LARGE",
+		modelType,
 		provider,
 		priority,
 		registeredAt: "test",
@@ -41,7 +46,7 @@ const strongDevice: DeviceTierAssessment = classifyDeviceTier({
 	cpuCores: 16,
 });
 
-// A 4 GB Chromebook-class box → POOR tier, mode "cloud-only".
+// A 4 GB box → POOR tier, mode "cloud-only".
 const weakDevice: DeviceTierAssessment = classifyDeviceTier({
 	...baseProbe,
 	totalRamGb: 4,
@@ -49,71 +54,252 @@ const weakDevice: DeviceTierAssessment = classifyDeviceTier({
 	cpuCores: 2,
 });
 
-describe("PolicyEngine — auto policy", () => {
-	it("classifier sanity: strong device favours local, weak device does not", () => {
+// An OKAY desktop: enough to run a local LM but NOT the local voice stack.
+// canRunLocalLm = true, canRunLocalVoice = false, recommendedMode = "local".
+const okayDesktop: DeviceTierAssessment = classifyDeviceTier({
+	...baseProbe,
+	totalRamGb: 16,
+	freeRamGb: 6,
+	cpuCores: 8,
+});
+
+const NO_LIVE_DEMOTION: LiveDeviceSignals = {
+	thermalState: "nominal",
+	decodeTokensPerSecond: 40,
+};
+
+function pickAuto(args: {
+	slot?: AgentModelSlot;
+	modelType?: string;
+	candidates: HandlerRegistration[];
+	deviceTier?: DeviceTierAssessment | null;
+	liveSignals?: LiveDeviceSignals | null;
+}): HandlerRegistration | null {
+	return policyEngine.pickProvider({
+		modelType: args.modelType ?? "TEXT_LARGE",
+		policy: "auto",
+		preferredProvider: null,
+		candidates: args.candidates,
+		selfProvider: "eliza-router",
+		slot: args.slot,
+		deviceTier: args.deviceTier,
+		liveSignals: args.liveSignals,
+	});
+}
+
+describe("PolicyEngine — auto policy (static tier)", () => {
+	it("classifier sanity: strong favours local, weak does not, OKAY desktop splits", () => {
 		expect(strongDevice.tier).toBe("MAX");
 		expect(strongDevice.recommendedMode).toBe("local");
 		expect(strongDevice.canRunLocalLm).toBe(true);
+		expect(strongDevice.canRunLocalVoice).toBe(true);
+
 		expect(weakDevice.tier).toBe("POOR");
 		expect(weakDevice.canRunLocalLm).toBe(false);
+
+		expect(okayDesktop.tier).toBe("OKAY");
+		expect(okayDesktop.recommendedMode).toBe("local");
+		expect(okayDesktop.canRunLocalLm).toBe(true);
+		expect(okayDesktop.canRunLocalVoice).toBe(false);
 	});
 
 	it("routes a strong device to the local provider", () => {
-		const pick = policyEngine.pickProvider({
-			modelType: "TEXT_LARGE",
-			policy: "auto",
-			preferredProvider: null,
+		const pick = pickAuto({
+			slot: "TEXT_LARGE",
 			candidates: [
 				registration("eliza-local-inference", -100),
 				registration("anthropic", 0),
 			],
-			selfProvider: "eliza-router",
 			deviceTier: strongDevice,
+			liveSignals: NO_LIVE_DEMOTION,
 		});
 		expect(pick?.provider).toBe("eliza-local-inference");
 	});
 
 	it("routes a weak device to the highest-priority cloud provider", () => {
-		const pick = policyEngine.pickProvider({
-			modelType: "TEXT_LARGE",
-			policy: "auto",
-			preferredProvider: null,
+		const pick = pickAuto({
+			slot: "TEXT_LARGE",
 			candidates: [
 				registration("eliza-local-inference", -100),
 				registration("anthropic", 0),
 				registration("elizacloud", 50),
 			],
-			selfProvider: "eliza-router",
 			deviceTier: weakDevice,
 		});
 		expect(pick?.provider).toBe("elizacloud");
 	});
 
 	it("falls back to cloud when no device assessment is available", () => {
+		const pick = pickAuto({
+			slot: "TEXT_LARGE",
+			candidates: [
+				registration("eliza-local-inference", -100),
+				registration("anthropic", 0),
+			],
+			deviceTier: null,
+		});
+		expect(pick?.provider).toBe("anthropic");
+	});
+
+	it("uses the only available provider even if it is local on a weak device", () => {
+		const pick = pickAuto({
+			slot: "TEXT_LARGE",
+			candidates: [registration("eliza-local-inference", -100)],
+			deviceTier: weakDevice,
+		});
+		expect(pick?.provider).toBe("eliza-local-inference");
+	});
+});
+
+describe("PolicyEngine — auto policy AC3 live-signal demotion", () => {
+	const candidates = () => [
+		registration("eliza-local-inference", -100),
+		registration("anthropic", 0),
+	];
+
+	it("demotes a strong device to cloud under SERIOUS thermal throttling", () => {
+		const pick = pickAuto({
+			slot: "TEXT_LARGE",
+			candidates: candidates(),
+			deviceTier: strongDevice,
+			liveSignals: { thermalState: "serious", decodeTokensPerSecond: 40 },
+		});
+		expect(pick?.provider).toBe("anthropic");
+	});
+
+	it("demotes a strong device to cloud under CRITICAL thermal throttling", () => {
+		const pick = pickAuto({
+			slot: "TEXT_LARGE",
+			candidates: candidates(),
+			deviceTier: strongDevice,
+			liveSignals: { thermalState: "critical", decodeTokensPerSecond: 40 },
+		});
+		expect(pick?.provider).toBe("anthropic");
+	});
+
+	it("demotes a strong device to cloud when decode TPS is below budget", () => {
+		const pick = pickAuto({
+			slot: "TEXT_LARGE",
+			candidates: candidates(),
+			deviceTier: strongDevice,
+			liveSignals: { thermalState: "nominal", decodeTokensPerSecond: 2 },
+		});
+		expect(pick?.provider).toBe("anthropic");
+	});
+
+	it("does NOT demote on fair thermal + healthy TPS", () => {
+		const pick = pickAuto({
+			slot: "TEXT_LARGE",
+			candidates: candidates(),
+			deviceTier: strongDevice,
+			liveSignals: { thermalState: "fair", decodeTokensPerSecond: 40 },
+		});
+		expect(pick?.provider).toBe("eliza-local-inference");
+	});
+
+	it("does NOT demote when live signals are unmeasured (null)", () => {
+		const pick = pickAuto({
+			slot: "TEXT_LARGE",
+			candidates: candidates(),
+			deviceTier: strongDevice,
+			liveSignals: { thermalState: null, decodeTokensPerSecond: null },
+		});
+		expect(pick?.provider).toBe("eliza-local-inference");
+	});
+});
+
+describe("PolicyEngine — auto policy AC4 per-modality independence", () => {
+	it("one OKAY-desktop assessment yields local TEXT_LARGE + cloud TEXT_TO_SPEECH", () => {
+		const textPick = pickAuto({
+			slot: "TEXT_LARGE",
+			modelType: "TEXT_LARGE",
+			candidates: [
+				registration("eliza-local-inference", -100, "TEXT_LARGE"),
+				registration("anthropic", 0, "TEXT_LARGE"),
+			],
+			deviceTier: okayDesktop,
+			liveSignals: NO_LIVE_DEMOTION,
+		});
+		const voicePick = pickAuto({
+			slot: "TEXT_TO_SPEECH",
+			modelType: "TEXT_TO_SPEECH",
+			candidates: [
+				registration("eliza-local-inference", -100, "TEXT_TO_SPEECH"),
+				registration("elizacloud", 50, "TEXT_TO_SPEECH"),
+			],
+			deviceTier: okayDesktop,
+			liveSignals: NO_LIVE_DEMOTION,
+		});
+
+		// Same device, same instant — text stays on-device, voice goes to cloud.
+		expect(textPick?.provider).toBe("eliza-local-inference");
+		expect(voicePick?.provider).toBe("elizacloud");
+	});
+
+	it("TRANSCRIPTION (voice slot) also routes to cloud on OKAY desktop", () => {
+		const pick = pickAuto({
+			slot: "TRANSCRIPTION",
+			modelType: "TRANSCRIPTION",
+			candidates: [
+				registration("eliza-local-inference", -100, "TRANSCRIPTION"),
+				registration("elizacloud", 50, "TRANSCRIPTION"),
+			],
+			deviceTier: okayDesktop,
+			liveSignals: NO_LIVE_DEMOTION,
+		});
+		expect(pick?.provider).toBe("elizacloud");
+	});
+});
+
+describe("PolicyEngine — local-only / cloud-only (AC2)", () => {
+	it("local-only always returns the local provider, never cloud", () => {
 		const pick = policyEngine.pickProvider({
 			modelType: "TEXT_LARGE",
-			policy: "auto",
+			policy: "local-only",
 			preferredProvider: null,
 			candidates: [
 				registration("eliza-local-inference", -100),
+				registration("anthropic", 999),
+			],
+			selfProvider: "eliza-router",
+		});
+		expect(pick?.provider).toBe("eliza-local-inference");
+	});
+
+	it("local-only returns null when no local handler exists (no silent cloud fallback)", () => {
+		const pick = policyEngine.pickProvider({
+			modelType: "TEXT_LARGE",
+			policy: "local-only",
+			preferredProvider: null,
+			candidates: [registration("anthropic", 0)],
+			selfProvider: "eliza-router",
+		});
+		expect(pick).toBeNull();
+	});
+
+	it("cloud-only always returns a cloud provider, never local", () => {
+		const pick = policyEngine.pickProvider({
+			modelType: "TEXT_LARGE",
+			policy: "cloud-only",
+			preferredProvider: null,
+			candidates: [
+				registration("eliza-local-inference", 999),
 				registration("anthropic", 0),
 			],
 			selfProvider: "eliza-router",
-			deviceTier: null,
 		});
 		expect(pick?.provider).toBe("anthropic");
 	});
 
-	it("uses the only available provider even if it is local on a weak device", () => {
+	it("cloud-only returns null when only local handlers exist", () => {
 		const pick = policyEngine.pickProvider({
 			modelType: "TEXT_LARGE",
-			policy: "auto",
+			policy: "cloud-only",
 			preferredProvider: null,
-			candidates: [registration("eliza-local-inference", -100)],
+			candidates: [registration("eliza-local-inference", 0)],
 			selfProvider: "eliza-router",
-			deviceTier: weakDevice,
 		});
-		expect(pick?.provider).toBe("eliza-local-inference");
+		expect(pick).toBeNull();
 	});
 });
 
@@ -142,6 +328,7 @@ describe("PolicyEngine — prefer-local capability soft-hint", () => {
 				registration("anthropic", 0),
 			],
 			selfProvider: "eliza-router",
+			slot: "TEXT_LARGE",
 			deviceTier: weakDevice,
 		});
 		expect(pick?.provider).toBe("anthropic");
@@ -157,6 +344,7 @@ describe("PolicyEngine — prefer-local capability soft-hint", () => {
 				registration("anthropic", 0),
 			],
 			selfProvider: "eliza-router",
+			slot: "TEXT_LARGE",
 			deviceTier: strongDevice,
 		});
 		expect(pick?.provider).toBe("eliza-local-inference");

package/src/services/routing-policy.ts

@@ -10,18 +10,25 @@
  *   - manual       — honour `preferredProvider`; when no pref set, fall
  *                    through to the runtime's native priority order
  *                    (highest registered priority wins).
- *   - auto         — capability-driven: consult the device-tier assessment.
- *                    When the device can comfortably run local inference
- *                    (recommended mode "local", or a MAX/GOOD tier) AND a
- *                    local handler is registered for the slot, pick local.
+ *   - auto         — capability-driven: consult the device-tier assessment AND
+ *                    the live device signals (thermal + decode throughput). Route
+ *                    local only when the device can comfortably run the slot's
+ *                    modality (text → `canRunLocalLm`, voice → `canRunLocalVoice`)
+ *                    AND it is not currently throttled / below the TPS budget.
  *                    Otherwise pick the highest-priority cloud provider.
  *   - cheapest     — pick the provider with the lowest per-token cost.
  *   - fastest      — pick the provider with the lowest tracked p50 latency
  *                    (needs at least a few samples; falls back to native).
  *   - prefer-local — try local first; if it fails or has no handler,
- *                    fall through to the next-best non-local. A POOR device
- *                    tier (cannot run a local LM) softly demotes the local
+ *                    fall through to the next-best non-local. A device that
+ *                    cannot run the slot's modality softly demotes the local
  *                    pick so an unusable on-device path isn't forced.
+ *   - local-only   — always on-device: never returns a cloud provider. When no
+ *                    local handler is registered, returns `null` so the caller
+ *                    surfaces "no local provider" instead of silently routing
+ *                    to a paid API.
+ *   - cloud-only   — always off-device: never returns a local provider. Returns
+ *                    `null` when only local handlers exist.
  *   - round-robin  — distribute load evenly across eligible providers.
  *
  * Latency is tracked in a ring buffer per provider per model type. Cost
@@ -32,7 +39,10 @@
 
 import type { DeviceTierAssessment } from "./device-tier";
 import type { HandlerRegistration } from "./handler-registry";
+import type { LiveDeviceSignals } from "./live-signals";
+import { liveSignalsDemoteLocal } from "./live-signals";
 import type { RoutingPolicy } from "./routing-preferences";
+import type { AgentModelSlot } from "./types";
 
 const RING_SIZE = 32;
 
@@ -47,6 +57,12 @@ function isLocalProvider(provider: string): boolean {
 	return LOCAL_PROVIDERS.has(provider);
 }
 
+/** Voice slots use `canRunLocalVoice`; text slots use `canRunLocalLm`. */
+const VOICE_SLOTS: ReadonlySet<AgentModelSlot> = new Set([
+	"TEXT_TO_SPEECH",
+	"TRANSCRIPTION",
+]);
+
 /**
  * The first registered local handler in priority order, or null. Prefers the
  * in-process / Capacitor backends over the device bridge, matching the
@@ -65,14 +81,33 @@ function findLocalCandidate(
 }
 
 /**
- * Whether the device is strong enough to default to local inference. True when
- * the tier classifier recommends a local-first mode or lands the device in the
- * top two tiers (MAX/GOOD). A POOR device — or one the classifier steers to
- * cloud — returns false so `auto` routes to cloud.
+ * Whether the device can run this slot's modality locally *at all*, per the
+ * static tier assessment. Voice slots gate on `canRunLocalVoice` (the ASR + TTS
+ * budget is stricter than text); every other slot gates on `canRunLocalLm`.
+ * This is the per-modality independence AC4 requires — one assessment can yield
+ * local text + cloud voice (OKAY desktop) simultaneously.
+ */
+function modalityViableForSlot(
+	assessment: DeviceTierAssessment,
+	slot: AgentModelSlot | undefined,
+): boolean {
+	return slot !== undefined && VOICE_SLOTS.has(slot)
+		? assessment.canRunLocalVoice
+		: assessment.canRunLocalLm;
+}
+
+/**
+ * Whether `auto` should default this slot to local: the modality must be viable
+ * AND the device must be a generally local-first machine (recommended "local",
+ * or a MAX/GOOD tier). A device that merely *can* run the modality but is steered
+ * to cloud by the classifier does not get a local default.
  */
-function deviceFavoursLocal(assessment: DeviceTierAssessment | null): boolean {
+function tierFavoursLocalForSlot(
+	assessment: DeviceTierAssessment | null,
+	slot: AgentModelSlot | undefined,
+): boolean {
 	if (!assessment) return false;
-	if (!assessment.canRunLocalLm) return false;
+	if (!modalityViableForSlot(assessment, slot)) return false;
 	return (
 		assessment.recommendedMode === "local" ||
 		assessment.tier === "MAX" ||
@@ -194,11 +229,25 @@ class PolicyEngine {
 		/** Provider ID of the router itself — always excluded from candidates. */
 		selfProvider: string;
 		/**
-		 * Device-capability assessment from `classifyDeviceTier()`. Consulted by
-		 * the `auto` policy and used as a soft hint by `prefer-local`. Null when
-		 * the host hasn't probed hardware yet — `auto` then falls back to cloud.
+		 * The agent slot being routed. Drives the per-modality `auto` gate:
+		 * voice slots (`TEXT_TO_SPEECH` / `TRANSCRIPTION`) check
+		 * `canRunLocalVoice`; every other slot checks `canRunLocalLm`.
+		 */
+		slot?: AgentModelSlot;
+		/**
+		 * Static device-capability assessment from `classifyDeviceTier()`.
+		 * Consulted by `auto` (per-modality gate) and used as a soft hint by
+		 * `prefer-local`. Null when the host hasn't probed hardware yet — `auto`
+		 * then falls back to cloud.
 		 */
 		deviceTier?: DeviceTierAssessment | null;
+		/**
+		 * Live device signals (thermal + decode throughput). When the device is
+		 * currently throttled or below the TPS budget, `auto` demotes a local
+		 * pick to cloud even if the static tier favoured local. Null = no live
+		 * demotion (the static decision stands).
+		 */
+		liveSignals?: LiveDeviceSignals | null;
 	}): HandlerRegistration | null {
 		const eligible = args.candidates
 			.filter((c) => c.provider !== args.selfProvider)
@@ -221,16 +270,35 @@ class PolicyEngine {
 				return eligible[0] ?? null;
 			}
 			case "auto": {
-				// Capability-driven: route to local only when the device can
-				// comfortably run it AND a local handler is registered for the
-				// slot. Otherwise pick the highest-priority cloud provider.
+				// Capability-driven: route local only when the device can run this
+				// slot's modality (per-modality gate: text → canRunLocalLm, voice →
+				// canRunLocalVoice) AND it is not currently throttled / below the TPS
+				// budget. Otherwise pick the highest-priority cloud provider.
 				const local = findLocalCandidate(eligible);
-				if (local && deviceFavoursLocal(args.deviceTier ?? null)) {
+				const tierFavours = tierFavoursLocalForSlot(
+					args.deviceTier ?? null,
+					args.slot,
+				);
+				const liveDemotes =
+					args.liveSignals != null && liveSignalsDemoteLocal(args.liveSignals);
+				if (local && tierFavours && !liveDemotes) {
 					return local;
 				}
 				const cloud = eligible.find((c) => !isLocalProvider(c.provider));
 				return cloud ?? eligible[0] ?? null;
 			}
+			case "local-only": {
+				// Hard local guarantee: only ever return an on-device handler. When
+				// none is registered we return null so the dispatch loop fails
+				// closed — it never silently falls through to a cloud provider.
+				// This is the per-slot canonical replacement for ELIZA_LOCAL_ONLY.
+				return findLocalCandidate(eligible);
+			}
+			case "cloud-only": {
+				// Force cloud: never dispatch to an on-device backend. Returns null
+				// (→ dispatch fails closed) when only local handlers are registered.
+				return eligible.find((c) => !isLocalProvider(c.provider)) ?? null;
+			}
 			case "cheapest": {
 				const ranked = [...eligible].sort((a, b) => {
 					const ca = this.costOf(a.provider) ?? Number.POSITIVE_INFINITY;
@@ -256,12 +324,13 @@ class PolicyEngine {
 			}
 			case "prefer-local": {
 				const local = findLocalCandidate(eligible);
-				// Soft capability hint: a known-POOR device (cannot run a local
-				// LM) demotes the local pick so we don't force an unusable
+				// Soft capability hint: a device that cannot run this slot's
+				// modality demotes the local pick so we don't force an unusable
 				// on-device path. When no assessment is present, keep the
 				// historical local-first behaviour.
 				const tier = args.deviceTier ?? null;
-				const localUnviable = tier !== null && !tier.canRunLocalLm;
+				const localUnviable =
+					tier !== null && !modalityViableForSlot(tier, args.slot);
 				if (local && !localUnviable) return local;
 				const cloud = eligible.find((c) => !isLocalProvider(c.provider));
 				if (cloud) return cloud;
@@ -278,6 +347,7 @@ class PolicyEngine {
 				return ranked[0] ?? null;
 			}
 		}
+		return eligible[0] ?? null;
 	}
 
 	/** For tests and diagnostics. */

package/src/services/service.test.ts

@@ -93,8 +93,8 @@ describe("LocalInferenceService activation prewarm", () => {
 		const prewarm = vi
 			.spyOn(localInferenceEngine, "prewarmConversation")
 			.mockResolvedValue(true);
-		const voiceReady = vi
-			.spyOn(localInferenceEngine, "ensureActiveBundleVoiceReady")
+		const asrReady = vi
+			.spyOn(localInferenceEngine, "ensureActiveBundleAsrReady")
 			.mockResolvedValue({} as never);
 		const transcribe = vi
 			.spyOn(localInferenceEngine, "transcribePcm")
@@ -122,7 +122,7 @@ describe("LocalInferenceService activation prewarm", () => {
 				"stable-stage1-prefix",
 			);
 		});
-		expect(voiceReady).toHaveBeenCalledOnce();
+		expect(asrReady).toHaveBeenCalledOnce();
 		expect(transcribe).toHaveBeenCalledWith({
 			pcm: expect.any(Float32Array),
 			sampleRate: 16_000,

package/src/services/service.ts

@@ -26,7 +26,6 @@ import { MODEL_CATALOG } from "./catalog";
 import { Downloader } from "./downloader";
 import { localInferenceEngine } from "./engine";
 import { probeHardware } from "./hardware";
-import { searchHuggingFaceGguf, searchModelHubGguf } from "./hf-search";
 import {
 	createImageGenCapabilityRegistration,
 	type ImageGenBackend,
@@ -286,10 +285,8 @@ export class LocalInferenceService {
 		return null;
 	}
 
-	async startDownload(
-		modelIdOrSpec: string | CatalogModel,
-	): Promise<DownloadJob> {
-		return this.downloader.start(modelIdOrSpec);
+	async startDownload(modelId: string): Promise<DownloadJob> {
+		return this.downloader.start(modelId);
 	}
 
 	async startSmallerFallbackDownload(
@@ -314,7 +311,9 @@ export class LocalInferenceService {
 		query: string,
 		limit?: number,
 	): Promise<CatalogModel[]> {
-		return searchHuggingFaceGguf(query, limit);
+		void query;
+		void limit;
+		return [];
 	}
 
 	async searchModelHub(
@@ -322,7 +321,10 @@ export class LocalInferenceService {
 		hub: "huggingface" | "modelscope",
 		limit?: number,
 	): Promise<CatalogModel[]> {
-		return searchModelHubGguf(query, hub, limit);
+		void query;
+		void hub;
+		void limit;
+		return [];
 	}
 
 	/**
@@ -498,6 +500,12 @@ export class LocalInferenceService {
 					0,
 					Math.floor(totalmem() / (1024 * 1024)) - ramHeadroomReserveMb(),
 				),
+			// The dominant resident consumer — the active text/embedding bundle —
+			// is owned by the engine, not the arbiter's resident map. Feed its
+			// footprint in so the proactive fit-to-budget `evictToFit` path
+			// actually trips before a second model overcommits RAM, instead of
+			// silently no-opping on the two roles that matter most (#8809 AC#1).
+			externalFootprintMb: () => localInferenceEngine.getResidentFootprintMb(),
 		});
 		arbiter.start();
 		setMemoryArbiter(arbiter);
@@ -528,6 +536,13 @@ export class LocalInferenceService {
 								maxTokens: request.maxTokens,
 								temperature: request.temperature,
 								signal: request.signal,
+								// Stream the description token-by-token when the caller wired
+								// a chunk sink (the IMAGE_DESCRIPTION handler forwards the
+								// runtime's onStreamChunk here); the engine/backend decode
+								// it through the same pipe as chat text when the fused lib
+								// exposes ABI-v13 streaming vision.
+								onTextChunk: request.onTextChunk,
+								maxTokensPerStep: request.maxTokensPerStep,
 							});
 							const trimmed = result.text.trim();
 							if (!trimmed) {

package/src/services/transcription-priority.test.ts

@@ -2,7 +2,7 @@
  * Tests for the `TRANSCRIPTION` model handler priority + provider hint
  * semantics on `AgentRuntime`. These exercise the same `registerModel`
  * machinery used by plugin-elizacloud (remote OpenAI Whisper API) and the
- * local fused Qwen3-ASR handler so callers know exactly:
+ * local fused Gemma ASR handler so callers know exactly:
  *
  *   - which handler wins when priorities tie (first-registered),
  *   - how an explicit `priority` overrides that,
@@ -60,7 +60,7 @@ function makeHandler(
 }
 
 describe("TRANSCRIPTION handler priority on AgentRuntime", () => {
-	it("local Qwen3-ASR wins over remote OpenAI Whisper by registration order when priorities tie", async () => {
+	it("local Gemma ASR wins over remote OpenAI Whisper by registration order when priorities tie", async () => {
 		const { runtime, calls } = makeRuntime();
 		runtime.registerModel(
 			ModelType.TRANSCRIPTION,

package/src/services/types.ts

@@ -15,6 +15,8 @@ export {
 	type CatalogQuantizationMatrix,
 	type CatalogQuantizationVariant,
 	type CpuFeatureProbe,
+	classifyCatalogModelRuntimeClass,
+	classifyInstalledModelRuntimeClass,
 	type DownloadEvent,
 	type DownloadJob,
 	type DownloadState,
@@ -38,9 +40,11 @@ export {
 	type ModelHubSnapshot,
 	type OpenVinoDeviceKind,
 	type OpenVinoHardwareProbe,
+	type RuntimeClass,
 	TEXT_GENERATION_SLOTS,
 	type TextGenerationSlot,
 	type TokenizerFamily,
+	withRuntimeClass,
 } from "@elizaos/shared";
 
 /** RAM requirements for a model bundle. */

package/src/services/verify-on-device.test.ts

@@ -32,10 +32,10 @@ function verifier() {
 }
 
 const ARGS = {
-	modelId: "eliza-1-0_8b",
+	modelId: "eliza-1-2b",
 	bundleRoot: "/tmp/bundle",
 	manifestPath: "/tmp/bundle/eliza-1.manifest.json",
-	textGgufPath: "/tmp/bundle/text/eliza-1-0_8b.gguf",
+	textGgufPath: "/tmp/bundle/text/eliza-1-2b.gguf",
 };
 
 afterEach(() => {

package/src/services/vision/hash.ts

@@ -34,7 +34,7 @@
 import { createHash } from "node:crypto";
 import type { VisionImageInput } from "./types";
 
-const DEFAULT_FAMILY = "qwen3-vl";
+const DEFAULT_FAMILY = "gemma-vl";
 
 /**
  * Resolve a `VisionImageInput` to its raw bytes. Returns the decoded