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

package/src/adapters/capacitor-llama/native-voice-capture.ts

@@ -0,0 +1,140 @@
+/**
+ * Native PCM capture coordinator for the Capacitor / AOSP voice path.
+ *
+ * Platform mic front-ends own capture and VAD/turn segmentation. This class is
+ * the TypeScript bridge they call with a completed PCM turn: it serializes the
+ * turn through {@link runDeviceVoiceTurn}, which joins ASR, speaker attribution,
+ * response policy, text generation, and TTS in the fused voice path.
+ */
+
+import type { VoicePipelineEvents } from "../../services/voice/pipeline";
+import type { TranscriptionAudio } from "../../services/voice/types";
+import type { VoicePreloadPredictor } from "../../services/voice/voice-preload-predictor";
+import type { CapacitorLlamaContext } from "./types";
+import {
+	type CapacitorTextRunnerOptions,
+	type DeviceVoiceEngine,
+	runDeviceVoiceTurn,
+	type VoiceTurnExitReason,
+} from "./voice-turn";
+
+export interface NativePcmVoiceTurn {
+	/** Captured mic PCM for one VAD-completed native turn. */
+	audio: TranscriptionAudio;
+	/** Optional host turn id, useful for traces and logs. */
+	turnId?: string;
+	/** Per-turn event hooks. Falls back to coordinator defaults when omitted. */
+	events?: VoicePipelineEvents;
+	/** Per-turn generated-token cap. Falls back to coordinator defaults. */
+	maxGeneratedTokens?: number;
+	/** Per-turn sampling overrides. Falls back to coordinator defaults. */
+	generation?: CapacitorTextRunnerOptions;
+	/** Per-turn preload predictor. Falls back to coordinator defaults. */
+	preloadPredictor?: VoicePreloadPredictor;
+}
+
+export interface NativePcmVoiceTurnCoordinatorOptions {
+	/** The engine that owns the armed voice bridge (`startVoice` + `armVoice`). */
+	engine: DeviceVoiceEngine;
+	/** Loaded on-device text model context for the MTP target verifier. */
+	context: CapacitorLlamaContext;
+	/** Default pipeline events for every accepted native turn. */
+	events?: VoicePipelineEvents;
+	/** Default generated-token cap for every accepted native turn. */
+	maxGeneratedTokens?: number;
+	/** Default sampling overrides for the on-device text runner. */
+	generation?: CapacitorTextRunnerOptions;
+	/** Default next-stage preload predictor. */
+	preloadPredictor?: VoicePreloadPredictor;
+}
+
+export interface NativePcmVoiceTurnResult {
+	turnId?: string;
+	exitReason: VoiceTurnExitReason;
+}
+
+/**
+ * Serializes native completed PCM turns into the fused device voice engine.
+ *
+ * Native capture can emit turns quickly, especially when a flush returns more
+ * than one segment. The fused voice bridge only allows one active turn; this
+ * coordinator preserves order by queueing each accepted turn after the previous
+ * `runDeviceVoiceTurn` settles.
+ */
+export class NativePcmVoiceTurnCoordinator {
+	private readonly options: NativePcmVoiceTurnCoordinatorOptions;
+	private queue: Promise<void> = Promise.resolve();
+	private running = false;
+
+	constructor(options: NativePcmVoiceTurnCoordinatorOptions) {
+		this.options = options;
+	}
+
+	get isRunning(): boolean {
+		return this.running;
+	}
+
+	start(): void {
+		this.running = true;
+	}
+
+	async stop(): Promise<void> {
+		this.running = false;
+		await this.queue;
+	}
+
+	/**
+	 * Accept one VAD-completed native PCM turn and run it through the fused
+	 * device voice path. Throws when the coordinator has not been started so
+	 * callers cannot accidentally bypass the capture lifecycle.
+	 */
+	acceptTurn(turn: NativePcmVoiceTurn): Promise<NativePcmVoiceTurnResult> {
+		if (!this.running) {
+			return Promise.reject(
+				new Error(
+					"[native-voice-capture] cannot accept a PCM turn before start()",
+				),
+			);
+		}
+
+		const run = this.queue.then(async () => {
+			const exitReason = await runDeviceVoiceTurn({
+				engine: this.options.engine,
+				context: this.options.context,
+				audio: turn.audio,
+				...this.resolveTurnOptions(turn),
+			});
+			return {
+				...(turn.turnId ? { turnId: turn.turnId } : {}),
+				exitReason,
+			};
+		});
+
+		this.queue = run.then(
+			() => undefined,
+			() => undefined,
+		);
+		return run;
+	}
+
+	private resolveTurnOptions(
+		turn: NativePcmVoiceTurn,
+	): Pick<
+		Parameters<typeof runDeviceVoiceTurn>[0],
+		"events" | "generation" | "maxGeneratedTokens" | "preloadPredictor"
+	> {
+		const events = turn.events ?? this.options.events;
+		const maxGeneratedTokens =
+			turn.maxGeneratedTokens ?? this.options.maxGeneratedTokens;
+		const generation = turn.generation ?? this.options.generation;
+		const preloadPredictor =
+			turn.preloadPredictor ?? this.options.preloadPredictor;
+
+		return {
+			...(events ? { events } : {}),
+			...(maxGeneratedTokens !== undefined ? { maxGeneratedTokens } : {}),
+			...(generation ? { generation } : {}),
+			...(preloadPredictor ? { preloadPredictor } : {}),
+		};
+	}
+}

package/src/adapters/capacitor-llama/text-streaming.ts

@@ -126,7 +126,7 @@ export function streamCapacitorPrompt(
 			const resolver = pendingResolve;
 			pendingResolve = null;
 			pendingReject = null;
-			resolver({ value: undefined as unknown as string, done: true });
+			resolver({ value: undefined, done: true });
 		}
 	};
 
@@ -181,7 +181,7 @@ export function streamCapacitorPrompt(
 					}
 					if (promptDone) {
 						return Promise.resolve({
-							value: undefined as unknown as string,
+							value: undefined,
 							done: true,
 						});
 					}

package/src/adapters/capacitor-llama/voice-turn.ts

@@ -0,0 +1,178 @@
+/**
+ * On-device fused voice-turn entry for the Capacitor / AOSP device bridge.
+ *
+ * This is the production caller for `LocalInferenceEngine.runVoiceTurn` (#8786):
+ * the in-process fused mic→speech loop (ASR → {MTP drafts ∥ target verify} →
+ * phrase chunker → OmniVoice/Kokoro → PCM ring buffer) that the engine's voice
+ * bridge owns. The engine bridge serves ASR + TTS from the fused
+ * `libelizainference` handle; the DEVICE supplies its own text runner so the
+ * draft/verify loop runs on the on-device text model (the
+ * `CapacitorLlamaContext`-backed decode) rather than the desktop dispatcher —
+ * exactly the seam `runVoiceTurn`'s `textRunner` option was built for.
+ *
+ * The native iOS/Android mic-capture layer hands captured PCM to
+ * {@link runDeviceVoiceTurn}; everything downstream is in-process JS + the
+ * fused FFI. No HTTP, no second voice path.
+ */
+
+import type { GenerateArgs } from "../../services/backend";
+import type { VoicePipelineEvents } from "../../services/voice/pipeline";
+import type { MtpTextRunner } from "../../services/voice/pipeline-impls";
+import type {
+	TranscriptionAudio,
+	VerifierStreamEvent,
+} from "../../services/voice/types";
+import type { VoicePreloadPredictor } from "../../services/voice/voice-preload-predictor";
+import type { CapacitorLlamaContext } from "./types";
+
+/** Turn exit reason, mirroring `LocalInferenceEngine.runVoiceTurn`. */
+export type VoiceTurnExitReason = "done" | "token-cap" | "cancelled";
+
+/**
+ * Structural view of `LocalInferenceEngine.runVoiceTurn` so the device bridge
+ * (and tests) depend on the call shape, not the concrete engine class.
+ */
+export interface DeviceVoiceEngine {
+	runVoiceTurn(
+		audio: TranscriptionAudio,
+		opts?: {
+			maxDraftTokens?: number;
+			maxGeneratedTokens?: number;
+			events?: VoicePipelineEvents;
+			textRunner?: MtpTextRunner;
+		},
+	): Promise<VoiceTurnExitReason>;
+}
+
+export interface CapacitorTextRunnerOptions {
+	/** Default sampling temperature when the pipeline does not pin one. */
+	temperature?: number;
+	/** Default nucleus-sampling cutoff when the pipeline does not pin one. */
+	topP?: number;
+}
+
+/**
+ * Adapt a live `CapacitorLlamaContext` to the {@link MtpTextRunner} contract the
+ * fused voice pipeline drives.
+ *
+ * `hasDrafter()` is `false`: the on-device `CapacitorLlamaContext` does not yet
+ * expose a separate speculative-draft window, so the pipeline runs plain decode
+ * through the target verifier (`MtpTargetVerifier` splits the returned text into
+ * tokens when no per-delta verifier events arrive — its documented non-streaming
+ * path). When the on-device fork exposes draft/verify events this flips to
+ * `true` with no change to the call sites.
+ */
+export function createCapacitorMtpTextRunner(
+	context: CapacitorLlamaContext,
+	options: CapacitorTextRunnerOptions = {},
+): MtpTextRunner {
+	return {
+		hasDrafter() {
+			return false;
+		},
+		async generateWithVerifierEvents(
+			args: GenerateArgs & {
+				onVerifierEvent: (event: VerifierStreamEvent) => void | Promise<void>;
+			},
+		): Promise<{ text: string }> {
+			const { signal } = args;
+			if (signal?.aborted) return { text: "" };
+
+			// A barge-in / kill-switch aborts the in-flight on-device decode.
+			let onAbort: (() => void) | undefined;
+			if (signal) {
+				onAbort = () => {
+					void context.stopCompletion();
+				};
+				signal.addEventListener("abort", onAbort, { once: true });
+			}
+
+			try {
+				const result = await context.completion({
+					prompt: args.prompt,
+					n_predict: args.maxTokens,
+					temperature: args.temperature ?? options.temperature,
+					top_p: args.topP ?? options.topP,
+					...(args.stopSequences ? { stop: args.stopSequences } : {}),
+				});
+				return { text: result.text };
+			} finally {
+				if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+			}
+		},
+	};
+}
+
+export interface RunDeviceVoiceTurnArgs {
+	/** The engine that owns the armed voice bridge (`startVoice` + `armVoice`). */
+	engine: DeviceVoiceEngine;
+	/** The on-device text model context that backs the MTP target verifier. */
+	context: CapacitorLlamaContext;
+	/** Captured mic PCM for this turn. */
+	audio: TranscriptionAudio;
+	/** Pipeline events (first-audio, transcript, completion, cancel). */
+	events?: VoicePipelineEvents;
+	/** Upper bound on generated response tokens. */
+	maxGeneratedTokens?: number;
+	/** Default sampling overrides forwarded to the on-device text runner. */
+	generation?: CapacitorTextRunnerOptions;
+	/**
+	 * Next-stage preload predictor (#8809 C5). On the mobile / Capacitor path the
+	 * text-response model is owned by the {@link MemoryArbiter}; this turn's
+	 * stages run sequentially (ASR → text → TTS), so the predictor warms the
+	 * arbiter-managed text model the instant ASR finishes — during the ASR-stage
+	 * page-trim window — collapsing the cold load off the post-ASR critical path.
+	 * Wired to the pipeline's `onAsrComplete` event below. Omit to keep the turn
+	 * unpredicted (the arbiter still loads the text model on first request).
+	 */
+	preloadPredictor?: VoicePreloadPredictor;
+}
+
+/**
+ * Run one fused on-device voice turn. The native capture layer calls this with
+ * the captured mic audio; it builds the device text runner from the loaded
+ * `CapacitorLlamaContext` and drives `engine.runVoiceTurn`, so ASR + MTP +
+ * TTS all run in-process through the fused handle. Resolves with the turn's
+ * exit reason.
+ */
+export function runDeviceVoiceTurn(
+	args: RunDeviceVoiceTurnArgs,
+): Promise<VoiceTurnExitReason> {
+	const textRunner = createCapacitorMtpTextRunner(
+		args.context,
+		args.generation ?? {},
+	);
+	const events = composeAsrCompletePreload(args.events, args.preloadPredictor);
+	return args.engine.runVoiceTurn(args.audio, {
+		textRunner,
+		...(events ? { events } : {}),
+		...(args.maxGeneratedTokens !== undefined
+			? { maxGeneratedTokens: args.maxGeneratedTokens }
+			: {}),
+	});
+}
+
+/**
+ * Compose the caller's pipeline events with the next-stage preload prediction.
+ *
+ * When a predictor is supplied, its `onAsrStageComplete()` is invoked from the
+ * pipeline's `onAsrComplete` hook — the instant ASR emits its final token — so
+ * the arbiter-managed text model is warmed before the verifier issues its first
+ * request. The prediction is fire-and-forget: it must never delay the
+ * drafter/verifier kick-off, and a declined preload (pressure / no headroom) is
+ * a no-op, not an error. The caller's own `onAsrComplete` (if any) still runs.
+ */
+function composeAsrCompletePreload(
+	events: VoicePipelineEvents | undefined,
+	predictor: VoicePreloadPredictor | undefined,
+): VoicePipelineEvents | undefined {
+	if (!predictor) return events;
+	const callerOnAsrComplete = events?.onAsrComplete;
+	return {
+		...events,
+		onAsrComplete(tokens) {
+			callerOnAsrComplete?.(tokens);
+			void predictor.onAsrStageComplete();
+		},
+	};
+}

package/src/backends/apple-foundation.ts

@@ -10,7 +10,7 @@
  *     `ComputerUse` bridge probe, we register a generate function that
  *     calls into Apple's framework for short prompts.
  *   - Otherwise we do nothing, and the existing llama-cpp-capacitor
- *     (Qwen3-VL-2B) path remains the active local-inference handler.
+ *     (Gemma-VL / eliza-1 2b) path remains the active local-inference handler.
  *
  * Why this lives in plugin-local-inference (not plugin-capacitor-bridge):
  *

package/src/local-inference-routes.test.ts

@@ -124,6 +124,7 @@ import {
 	getLocalInferenceActiveSnapshot,
 	getLocalInferenceChatStatus,
 	handleLocalInferenceRoutes,
+	reauthorizeRedirectHeaders,
 } from "./local-inference-routes.js";
 
 const { aospMock, bridgeMock, serviceMock } = getRouteTestMocks();
@@ -234,7 +235,7 @@ describe("local inference chat status", () => {
 
 	it("uses the desktop active-model service state for chat status", async () => {
 		serviceMock.setActiveState({
-			modelId: "eliza-1-0_8b",
+			modelId: "eliza-1-2b",
 			loadedAt: "2026-05-16T02:22:23.512Z",
 			status: "ready",
 			loadedContextSize: 131_072,
@@ -244,22 +245,22 @@ describe("local inference chat status", () => {
 		});
 
 		await expect(getLocalInferenceActiveSnapshot()).resolves.toMatchObject({
-			modelId: "eliza-1-0_8b",
+			modelId: "eliza-1-2b",
 			status: "ready",
 			loadedContextSize: 131_072,
 			loadedGpuLayers: 99,
 		});
-		expect(getLocalInferenceActiveModelId()).toBe("eliza-1-0_8b");
+		expect(getLocalInferenceActiveModelId()).toBe("eliza-1-2b");
 
 		const status = await getLocalInferenceChatStatus("status");
 		expect(status.localInference).toMatchObject({
 			intent: "status",
 			status: "ready",
-			modelId: "eliza-1-0_8b",
-			activeModelId: "eliza-1-0_8b",
+			modelId: "eliza-1-2b",
+			activeModelId: "eliza-1-2b",
 			provider: "eliza-local-inference",
 		});
-		expect(status.text).toContain("Model: eliza-1-0_8b.");
+		expect(status.text).toContain("Model: eliza-1-2b.");
 		expect(status.text).not.toMatch(/none is loaded|waiting to be activated/i);
 	});
 
@@ -268,9 +269,9 @@ describe("local inference chat status", () => {
 		const modelPath = path.join(
 			root,
 			"models",
-			"eliza-1-0_8b.bundle",
+			"eliza-1-2b.bundle",
 			"text",
-			"eliza-1-0_8b-32k.gguf",
+			"eliza-1-2b-32k.gguf",
 		);
 		mkdirSync(path.dirname(modelPath), { recursive: true });
 		writeFileSync(modelPath, "GGUF");
@@ -280,8 +281,8 @@ describe("local inference chat status", () => {
 				version: 1,
 				models: [
 					{
-						id: "eliza-1-0_8b",
-						displayName: "eliza-1-0_8b",
+						id: "eliza-1-2b",
+						displayName: "eliza-1-2b",
 						path: modelPath,
 						runtimeRole: "chat",
 					},
@@ -301,7 +302,7 @@ describe("local inference chat status", () => {
 		);
 
 		await expect(getLocalInferenceActiveSnapshot()).resolves.toMatchObject({
-			modelId: "eliza-1-0_8b",
+			modelId: "eliza-1-2b",
 			status: "ready",
 			loadedAt: "2026-05-16T02:09:05.833Z",
 		});
@@ -342,3 +343,48 @@ describe("local inference chat status", () => {
 		});
 	});
 });
+
+describe("reauthorizeRedirectHeaders — no HF token leak across redirects", () => {
+	const savedToken = process.env.HF_TOKEN;
+	beforeEach(() => {
+		process.env.HF_TOKEN = "hf-secret-token";
+	});
+	afterEach(() => {
+		if (savedToken === undefined) delete process.env.HF_TOKEN;
+		else process.env.HF_TOKEN = savedToken;
+	});
+
+	const baseHeaders = {
+		"user-agent": "Eliza-MobileLocalInference/1.0",
+		authorization: "Bearer hf-secret-token",
+	};
+
+	it.each([
+		"https://cdn-lfs-us-1.hf.co/repo/abc123",
+		"https://prod-cas-shard.s3.amazonaws.com/abc?X-Amz-Signature=z",
+		"https://example.cloudfront.net/model.gguf",
+	])("strips Authorization when redirected cross-host to %s", (nextUrl) => {
+		const next = reauthorizeRedirectHeaders(baseHeaders, nextUrl);
+		expect(next.authorization).toBeUndefined();
+		expect(next.Authorization).toBeUndefined();
+		// Non-auth headers are preserved.
+		expect(next["user-agent"]).toBe("Eliza-MobileLocalInference/1.0");
+	});
+
+	it("keeps Authorization when the redirect target is still a HuggingFace host", () => {
+		const next = reauthorizeRedirectHeaders(
+			baseHeaders,
+			"https://huggingface.co/repo/resolve/main/model.gguf",
+		);
+		expect(next.authorization).toBe("Bearer hf-secret-token");
+	});
+
+	it("does not synthesize an Authorization header when none was configured", () => {
+		delete process.env.HF_TOKEN;
+		const next = reauthorizeRedirectHeaders(
+			{ "user-agent": "x" },
+			"https://huggingface.co/repo/resolve/main/model.gguf",
+		);
+		expect(next.authorization).toBeUndefined();
+	});
+});

package/src/local-inference-routes.ts

@@ -16,6 +16,7 @@ import {
 } from "@elizaos/core";
 import {
 	buildHuggingFaceResolveUrl,
+	resolveHubAuthHeaders,
 	MODEL_CATALOG as SHARED_MODEL_CATALOG,
 	type CatalogModel as SharedCatalogModel,
 } from "@elizaos/shared";
@@ -28,6 +29,7 @@ import {
 	assertManifestEvalsPassed,
 	CandidateModelActivationError,
 } from "./services/active-model.js";
+import { classifyDeviceTier } from "./services/device-tier.js";
 import { localInferenceService } from "./services/service.js";
 import { prewarmLocalVoiceStackForModel } from "./services/voice-prewarm.js";
 
@@ -73,7 +75,7 @@ let aospLocalInferenceApiPromise: Promise<AospLocalInferenceApi> | null = null;
 
 function getMobileDeviceBridgeApi(): Promise<MobileDeviceBridgeApi> {
 	mobileDeviceBridgeApiPromise ??= import(
-		"@elizaos/plugin-capacitor-bridge"
+		"@elizaos/plugin-capacitor-bridge/mobile-device-bridge-bootstrap"
 	) as Promise<MobileDeviceBridgeApi>;
 	return mobileDeviceBridgeApiPromise;
 }
@@ -114,6 +116,14 @@ interface CatalogModel extends SharedCatalogModel {
 	role: ModelRole;
 }
 
+const ASSIGNMENT_SLOTS = new Set<keyof Assignments>([
+	"TEXT_SMALL",
+	"TEXT_LARGE",
+	"TEXT_EMBEDDING",
+	"TEXT_TO_SPEECH",
+	"TRANSCRIPTION",
+]);
+
 interface InstalledModel {
 	id: string;
 	displayName: string;
@@ -212,6 +222,27 @@ const CATALOG: CatalogModel[] = SHARED_MODEL_CATALOG.map((model) => ({
 	role: catalogRole(model),
 }));
 
+function isCuratedCatalogModelId(modelId: string): boolean {
+	return CATALOG.some(
+		(model) =>
+			model.id === modelId &&
+			!model.hiddenFromCatalog &&
+			model.runtimeRole !== "mtp-drafter",
+	);
+}
+
+function sanitizeAssignments(assignments: Assignments): Assignments {
+	const next: Assignments = {};
+	for (const [slot, modelId] of Object.entries(assignments) as Array<
+		[keyof Assignments, string | undefined]
+	>) {
+		if (!modelId || !ASSIGNMENT_SLOTS.has(slot)) continue;
+		if (!isCuratedCatalogModelId(modelId)) continue;
+		next[slot] = modelId;
+	}
+	return next;
+}
+
 const activeDownloads = new Map<
 	string,
 	{ job: DownloadJob; abortController: AbortController }
@@ -297,6 +328,25 @@ const mobileLookup: http.RequestOptions["lookup"] = (
 	});
 };
 
+/**
+ * Recompute request headers when following a redirect. The HuggingFace bearer
+ * token must never leak past a cross-host redirect: HF `/resolve/` URLs 302 to
+ * cdn-lfs*.hf.co / *.amazonaws.com / *.cloudfront.net, none of which are HF
+ * hosts. Strip Authorization, then re-add it only if the redirect target is
+ * itself a HuggingFace host — mirroring the cross-origin auth stripping WHATWG
+ * fetch performs for the sibling `Downloader` path.
+ */
+export function reauthorizeRedirectHeaders(
+	headers: Record<string, string>,
+	nextUrl: string,
+): Record<string, string> {
+	const next: Record<string, string> = { ...headers };
+	delete next.authorization;
+	delete next.Authorization;
+	Object.assign(next, resolveHubAuthHeaders(nextUrl));
+	return next;
+}
+
 async function openDownloadResponse(
 	url: string,
 	headers: Record<string, string>,
@@ -322,10 +372,11 @@ async function openDownloadResponse(
 				const location = response.headers.location;
 				if (location && [301, 302, 303, 307, 308].includes(statusCode)) {
 					response.resume();
+					const nextUrl = new URL(location, parsed).toString();
 					resolve(
 						openDownloadResponse(
-							new URL(location, parsed).toString(),
-							headers,
+							nextUrl,
+							reauthorizeRedirectHeaders(headers, nextUrl),
 							signal,
 							redirectCount + 1,
 						),
@@ -446,7 +497,7 @@ async function readAssignments(): Promise<Assignments> {
 			assignments: {},
 		},
 	);
-	return file.assignments ?? {};
+	return sanitizeAssignments(file.assignments ?? {});
 }
 
 async function writeAssignments(
@@ -514,12 +565,14 @@ async function downloadModel(
 	record.updatedAt = new Date().toISOString();
 
 	try {
+		const downloadUrl = huggingFaceResolveUrl(model);
 		const headers: Record<string, string> = {
 			"user-agent": "Eliza-MobileLocalInference/1.0",
+			...resolveHubAuthHeaders(downloadUrl),
 		};
 		if (existingPartial > 0) headers.range = `bytes=${existingPartial}-`;
 		const response = await openDownloadResponse(
-			huggingFaceResolveUrl(model),
+			downloadUrl,
 			headers,
 			abortController.signal,
 		);
@@ -1178,6 +1231,12 @@ export async function handleLocalInferenceRoutes(
 		);
 		if (await handleVoiceFirstRunRoutes(req, res)) return true;
 	}
+	if (pathname === "/api/voice/native-pcm-turn") {
+		const { handleNativePcmTurnRoute } = await import(
+			"./routes/native-pcm-turn-route.js"
+		);
+		if (await handleNativePcmTurnRoute(req, res)) return true;
+	}
 	// Family-member capture route lives under /v1/voice/first-run/family-member.
 	if (pathname === "/v1/voice/first-run/family-member") {
 		const { handleFamilyMemberRoute } = await import(
@@ -1238,6 +1297,16 @@ export async function handleLocalInferenceRoutes(
 		sendJson(res, (await hubSnapshot()).hardware);
 		return true;
 	}
+	// The authoritative device-tier assessment (tier + recommendedMode +
+	// recommendedFit) — the same one the router's AUTO policy consumes. Mirrors
+	// the app-core compat route so mobile (which mounts this upstream variant)
+	// also gets the authoritative assessment instead of the coarse client estimate.
+	if (method === "GET" && pathname === "/api/local-inference/device-tier") {
+		sendJson(res, {
+			tier: classifyDeviceTier(await localInferenceService.getHardware()),
+		});
+		return true;
+	}
 	if (method === "GET" && pathname === "/api/local-inference/catalog") {
 		sendJson(res, {
 			models: CATALOG.filter((model) => !model.hiddenFromCatalog),
@@ -1307,13 +1376,22 @@ export async function handleLocalInferenceRoutes(
 		const body = await readJsonBody<Record<string, unknown>>(req, res);
 		if (!body) return true;
 		const slot = typeof body.slot === "string" ? body.slot : null;
-		if (!slot) {
+		if (!slot || !ASSIGNMENT_SLOTS.has(slot as keyof Assignments)) {
 			sendJsonError(res, "slot is required");
 			return true;
 		}
 		const assignments = await readAssignments();
 		if (typeof body.modelId === "string" && body.modelId.trim()) {
-			assignments[slot as keyof Assignments] = body.modelId.trim();
+			const modelId = body.modelId.trim();
+			if (!isCuratedCatalogModelId(modelId)) {
+				sendJsonError(
+					res,
+					"Local inference assignments are limited to curated Eliza-1 tiers.",
+					400,
+				);
+				return true;
+			}
+			assignments[slot as keyof Assignments] = modelId;
 		} else {
 			delete assignments[slot as keyof Assignments];
 		}
@@ -1535,7 +1613,11 @@ export async function handleLocalInferenceRoutes(
 		return true;
 	}
 	if (method === "GET" && pathname === "/api/local-inference/hf-search") {
-		sendJson(res, { models: [] });
+		sendJson(res, {
+			models: [],
+			disabled: true,
+			reason: "custom-model-search-disabled",
+		});
 		return true;
 	}