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

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

@@ -0,0 +1,127 @@
+/**
+ * Engine-backed `verifyOnDevice` hook for the Eliza-1 downloader
+ * (`packages/inference/AGENTS.md` §7): after a bundle is materialized and
+ * every file's sha256 checks out, run one cold smoke pass —
+ *
+ *   load → 1-token text generation → (if the bundle ships voice assets)
+ *   1-phrase voice generation → barge-in cancel → unload
+ *
+ * — before the bundle is allowed to auto-fill an empty default slot. The
+ * downloader stays decoupled from the engine: it only knows the
+ * {@link VerifyBundleOnDevice} shape; this module is the concrete
+ * implementation the service layer injects.
+ *
+ * Failure semantics: any error throws. The downloader catches it and leaves
+ * `bundleVerifiedAt` unset, so an unverified bundle is registered but does
+ * not become the recommended default. There is no "verified anyway" path —
+ * voice is mandatory for Eliza-1 voice tiers (AGENTS.md §3), so a bundle
+ * whose fused voice ABI is not loadable on this device legitimately fails
+ * verify until the fused build is present.
+ */
+
+import fs from "node:fs/promises";
+import type { VerifyBundleOnDevice } from "./downloader";
+import { localInferenceEngine } from "./engine";
+import { parseManifestOrThrow } from "./manifest";
+
+/** A short, deterministic prompt — we only care that one token comes back. */
+const VERIFY_PROMPT = "Reply with one word.";
+/** A short phrase to drive a single TTS dispatch through the voice scheduler. */
+const VERIFY_PHRASE = "Ready.";
+
+type VerifyEngine = Pick<
+	typeof localInferenceEngine,
+	| "load"
+	| "generate"
+	| "ensureActiveBundleVoiceReady"
+	| "startVoice"
+	| "armVoice"
+	| "synthesizeSpeech"
+	| "triggerBargeIn"
+	| "stopVoice"
+	| "unload"
+>;
+
+interface VerifyBundleOnDeviceDeps {
+	readonly engine: VerifyEngine;
+	readonly readFile: typeof fs.readFile;
+	readonly parseManifest: typeof parseManifestOrThrow;
+}
+
+async function manifestDeclaresVoice(
+	manifestPath: string,
+	deps: Pick<VerifyBundleOnDeviceDeps, "readFile" | "parseManifest">,
+): Promise<boolean> {
+	const raw = await deps.readFile(manifestPath, "utf8");
+	const manifest = deps.parseManifest(JSON.parse(String(raw)));
+	// Voice tiers ship a TTS GGUF under `files.voice`; the ASR/VAD files are
+	// gated on top of that. If there is no voice file, this is a text-only
+	// bundle and the voice leg of the smoke is skipped.
+	return manifest.files.voice.length > 0;
+}
+
+async function verifyText(
+	engine: VerifyEngine,
+	modelId: string,
+	textGgufPath: string,
+): Promise<void> {
+	await engine.load(textGgufPath, { modelPath: textGgufPath, modelId });
+	const out = await engine.generate({
+		prompt: VERIFY_PROMPT,
+		maxTokens: 1,
+		temperature: 0,
+	});
+	if (typeof out !== "string") {
+		throw new Error(
+			`[verify-on-device] text generation returned ${typeof out}, expected string`,
+		);
+	}
+}
+
+async function verifyVoice(
+	engine: VerifyEngine,
+	_bundleRoot: string,
+): Promise<void> {
+	await engine.ensureActiveBundleVoiceReady();
+	try {
+		// One real synthesis through the voice bridge.
+		const pcm = await engine.synthesizeSpeech(VERIFY_PHRASE);
+		if (!(pcm instanceof Uint8Array) || pcm.byteLength === 0) {
+			throw new Error(
+				"[verify-on-device] voice synthesis produced no PCM bytes",
+			);
+		}
+		// Barge-in cancel must be accepted without throwing — exercises the
+		// hard-stop path the voice loop uses to abort speculative TTS.
+		engine.triggerBargeIn();
+	} finally {
+		await engine.stopVoice();
+	}
+}
+
+export function createVerifyBundleOnDevice(
+	deps: Partial<VerifyBundleOnDeviceDeps> = {},
+): VerifyBundleOnDevice {
+	const engine = deps.engine ?? localInferenceEngine;
+	const manifestDeps = {
+		readFile: deps.readFile ?? fs.readFile,
+		parseManifest: deps.parseManifest ?? parseManifestOrThrow,
+	};
+
+	return async ({ modelId, bundleRoot, manifestPath, textGgufPath }) => {
+		try {
+			await verifyText(engine, modelId, textGgufPath);
+			if (await manifestDeclaresVoice(manifestPath, manifestDeps)) {
+				await verifyVoice(engine, bundleRoot);
+			}
+		} finally {
+			// Always release the model the verify pass loaded — the bundle is not
+			// "active" yet, and the active-model coordinator owns load/unload from
+			// here on.
+			await engine.unload().catch(() => {});
+		}
+	};
+}
+
+export const verifyBundleOnDevice: VerifyBundleOnDevice =
+	createVerifyBundleOnDevice();

package/src/services/verify.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Re-export of the shared model-file verification module. The canonical
+ * implementation lives in `@elizaos/shared/local-inference` because both
+ * the server (`@elizaos/app-core`) and the UI client (`@elizaos/ui`)
+ * compute the same SHA256 / GGUF-magic checks against on-disk models.
+ */
+export { __registryPathForTests, hashFile, type VerifyResult, type VerifyState, verifyInstalledModel, } from "@elizaos/shared/local-inference/verify";
+//# sourceMappingURL=verify.d.ts.map

package/src/services/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["verify.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EACN,sBAAsB,EACtB,QAAQ,EACR,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,oBAAoB,GACpB,MAAM,wCAAwC,CAAC"}

package/src/services/verify.ts

@@ -0,0 +1,13 @@
+/**
+ * Re-export of the shared model-file verification module. The canonical
+ * implementation lives in `@elizaos/shared/local-inference` because both
+ * the server (`@elizaos/app-core`) and the UI client (`@elizaos/ui`)
+ * compute the same SHA256 / GGUF-magic checks against on-disk models.
+ */
+export {
+	__registryPathForTests,
+	hashFile,
+	type VerifyResult,
+	type VerifyState,
+	verifyInstalledModel,
+} from "@elizaos/shared/local-inference/verify";

package/src/services/vision/aosp-unavailable.d.ts

@@ -0,0 +1,115 @@
+/**
+ * AOSP vision-describe backend contract (WS2).
+ *
+ * The bun:ffi llama.cpp binding in `@elizaos/plugin-aosp-local-inference`
+ * already exposes the embedding helpers (`llama_set_embeddings`,
+ * `llama_get_embeddings_seq`) and the model/context lifecycle. mtmd
+ * (multi-modal definition) is part of upstream llama.cpp from b8198+
+ * but the libeliza-llama-shim that the AOSP binding loads does NOT
+ * yet export the matching `eliza_llama_mtmd_*` symbols.
+ *
+ * This file is the JS contract for the FFI binding the AOSP plugin
+ * will add when the native side ships. It lives in
+ * `plugin-local-inference` (not in `plugin-aosp-local-inference`) so
+ * cross-plugin consumers can compile against the same interface
+ * regardless of platform. When the AOSP shim ships the native
+ * symbols, the implementation in `plugin-aosp-local-inference/src/
+ * aosp-llama-vision.ts` (to be added) will satisfy this contract.
+ *
+ * Required native symbols (libeliza-llama-shim):
+ *
+ *   eliza_llama_mtmd_init_from_file(
+ *     mmproj_path: const char *,
+ *     out_handle: void **
+ *   ) -> int32  // 0 = ok; non-zero = error code
+ *
+ *   eliza_llama_mtmd_free(mtmd_handle: void *) -> void
+ *
+ *   eliza_llama_mtmd_encode(
+ *     mtmd_handle: void *,
+ *     image_bytes: const uint8_t *,
+ *     image_len: size_t,
+ *     out_tokens_ptr: float **,   // owned by mtmd; valid until next encode
+ *     out_token_count: int32 *,
+ *     out_hidden_size: int32 *
+ *   ) -> int32
+ *
+ *   eliza_llama_decode_with_mmproj(
+ *     ctx: void *,                  // existing llama_context
+ *     mtmd_tokens: const float *,
+ *     mtmd_token_count: int32,
+ *     mtmd_hidden_size: int32,
+ *     prompt: const char *,
+ *     prompt_len: size_t,
+ *     max_tokens: int32,
+ *     temperature: float,
+ *     out_text_buf: char *,         // caller-allocated
+ *     out_text_buf_cap: size_t,
+ *     out_text_written: size_t *
+ *   ) -> int32
+ *
+ * Optional fast path: if the shim adds
+ *
+ *   eliza_llama_mtmd_describe(
+ *     model: void *,                // existing llama_model
+ *     ctx: void *,                  // existing llama_context
+ *     mtmd_handle: void *,
+ *     image_bytes: const uint8_t *,
+ *     image_len: size_t,
+ *     prompt: const char *,
+ *     prompt_len: size_t,
+ *     max_tokens: int32,
+ *     temperature: float,
+ *     out_buf: char *,
+ *     out_buf_cap: size_t,
+ *     out_written: size_t *
+ *   ) -> int32
+ *
+ * that single-call wrapper is preferred — it lets the shim fuse the
+ * encode+decode steps internally and avoids the round-trip of token
+ * pointers across the FFI boundary (which bun:ffi handles, but at the
+ * cost of two extra pointer dereferences per frame).
+ *
+ * Until the native side exports those symbols, this module's `loadAospVisionBackend`
+ * throws a structured error that the arbiter / handler can surface as
+ * "vision not available on this platform". It does NOT register
+ * silently — silent unavailability would let the runtime fall back to
+ * the cloud path on a mobile device that explicitly disabled it.
+ */
+import type { VisionDescribeBackend, VisionDescribeLoadArgs } from "./types";
+/**
+ * The AOSP binding's mtmd surface, when present. The AOSP plugin
+ * registers an instance under the runtime service name
+ * `"aosp-llama-mtmd"` once the native shim exports the symbols above.
+ */
+export interface AospLlamaMtmdBinding {
+    /** True when libeliza-llama-shim.so was loaded and exports the mtmd symbols. */
+    hasMtmd(): boolean;
+    /** Initialize an mtmd handle for the given mmproj path. */
+    initMtmd(args: {
+        mmprojPath: string;
+    }): Promise<AospMtmdHandle>;
+}
+export interface AospMtmdHandle {
+    /**
+     * Single-call describe — wraps mtmd_encode + decode_with_chunks. The
+     * AOSP shim's `eliza_llama_mtmd_describe` lands here. Backends that
+     * only have the split encode/decode symbols implement this on top
+     * of two FFI calls; backends with the fused symbol use one.
+     */
+    describe(args: {
+        imageBytes: Uint8Array;
+        prompt: string;
+        maxTokens?: number;
+        temperature?: number;
+        signal?: AbortSignal;
+    }): Promise<string>;
+    /** Free the mtmd handle (and any cached encode buffers). */
+    dispose(): Promise<void>;
+}
+export interface LoadAospVisionBackendOptions {
+    loadArgs: VisionDescribeLoadArgs;
+    mtmdBinding?: AospLlamaMtmdBinding;
+}
+export declare function loadAospVisionBackend(opts: LoadAospVisionBackendOptions): Promise<VisionDescribeBackend>;
+//# sourceMappingURL=aosp-unavailable.d.ts.map

package/src/services/vision/aosp-unavailable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aosp-unavailable.d.ts","sourceRoot":"","sources":["aosp-unavailable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6EG;AAIH,OAAO,KAAK,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAE7E;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACpC,gFAAgF;IAChF,OAAO,IAAI,OAAO,CAAC;IACnB,2DAA2D;IAC3D,QAAQ,CAAC,IAAI,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CAChE;AAED,MAAM,WAAW,cAAc;IAC9B;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE;QACd,UAAU,EAAE,UAAU,CAAC;QACvB,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,MAAM,CAAC,EAAE,WAAW,CAAC;KACrB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACpB,4DAA4D;IAC5D,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AAED,MAAM,WAAW,4BAA4B;IAC5C,QAAQ,EAAE,sBAAsB,CAAC;IACjC,WAAW,CAAC,EAAE,oBAAoB,CAAC;CACnC;AAED,wBAAsB,qBAAqB,CAC1C,IAAI,EAAE,4BAA4B,GAChC,OAAO,CAAC,qBAAqB,CAAC,CA0ChC"}

package/src/services/vision/aosp-unavailable.ts

@@ -0,0 +1,163 @@
+/**
+ * AOSP vision-describe backend contract (WS2).
+ *
+ * The bun:ffi llama.cpp binding in `@elizaos/plugin-aosp-local-inference`
+ * already exposes the embedding helpers (`llama_set_embeddings`,
+ * `llama_get_embeddings_seq`) and the model/context lifecycle. mtmd
+ * (multi-modal definition) is part of upstream llama.cpp from b8198+
+ * but the libeliza-llama-shim that the AOSP binding loads does NOT
+ * yet export the matching `eliza_llama_mtmd_*` symbols.
+ *
+ * This file is the JS contract for the FFI binding the AOSP plugin
+ * will add when the native side ships. It lives in
+ * `plugin-local-inference` (not in `plugin-aosp-local-inference`) so
+ * cross-plugin consumers can compile against the same interface
+ * regardless of platform. When the AOSP shim ships the native
+ * symbols, the implementation in `plugin-aosp-local-inference/src/
+ * aosp-llama-vision.ts` (to be added) will satisfy this contract.
+ *
+ * Required native symbols (libeliza-llama-shim):
+ *
+ *   eliza_llama_mtmd_init_from_file(
+ *     mmproj_path: const char *,
+ *     out_handle: void **
+ *   ) -> int32  // 0 = ok; non-zero = error code
+ *
+ *   eliza_llama_mtmd_free(mtmd_handle: void *) -> void
+ *
+ *   eliza_llama_mtmd_encode(
+ *     mtmd_handle: void *,
+ *     image_bytes: const uint8_t *,
+ *     image_len: size_t,
+ *     out_tokens_ptr: float **,   // owned by mtmd; valid until next encode
+ *     out_token_count: int32 *,
+ *     out_hidden_size: int32 *
+ *   ) -> int32
+ *
+ *   eliza_llama_decode_with_mmproj(
+ *     ctx: void *,                  // existing llama_context
+ *     mtmd_tokens: const float *,
+ *     mtmd_token_count: int32,
+ *     mtmd_hidden_size: int32,
+ *     prompt: const char *,
+ *     prompt_len: size_t,
+ *     max_tokens: int32,
+ *     temperature: float,
+ *     out_text_buf: char *,         // caller-allocated
+ *     out_text_buf_cap: size_t,
+ *     out_text_written: size_t *
+ *   ) -> int32
+ *
+ * Optional fast path: if the shim adds
+ *
+ *   eliza_llama_mtmd_describe(
+ *     model: void *,                // existing llama_model
+ *     ctx: void *,                  // existing llama_context
+ *     mtmd_handle: void *,
+ *     image_bytes: const uint8_t *,
+ *     image_len: size_t,
+ *     prompt: const char *,
+ *     prompt_len: size_t,
+ *     max_tokens: int32,
+ *     temperature: float,
+ *     out_buf: char *,
+ *     out_buf_cap: size_t,
+ *     out_written: size_t *
+ *   ) -> int32
+ *
+ * that single-call wrapper is preferred — it lets the shim fuse the
+ * encode+decode steps internally and avoids the round-trip of token
+ * pointers across the FFI boundary (which bun:ffi handles, but at the
+ * cost of two extra pointer dereferences per frame).
+ *
+ * Until the native side exports those symbols, this module's `loadAospVisionBackend`
+ * throws a structured error that the arbiter / handler can surface as
+ * "vision not available on this platform". It does NOT register
+ * silently — silent unavailability would let the runtime fall back to
+ * the cloud path on a mobile device that explicitly disabled it.
+ */
+
+import { existsSync } from "node:fs";
+import { VisionBackendUnavailableError } from "./capacitor-llama";
+import type { VisionDescribeBackend, VisionDescribeLoadArgs } from "./types";
+
+/**
+ * The AOSP binding's mtmd surface, when present. The AOSP plugin
+ * registers an instance under the runtime service name
+ * `"aosp-llama-mtmd"` once the native shim exports the symbols above.
+ */
+export interface AospLlamaMtmdBinding {
+	/** True when libeliza-llama-shim.so was loaded and exports the mtmd symbols. */
+	hasMtmd(): boolean;
+	/** Initialize an mtmd handle for the given mmproj path. */
+	initMtmd(args: { mmprojPath: string }): Promise<AospMtmdHandle>;
+}
+
+export interface AospMtmdHandle {
+	/**
+	 * Single-call describe — wraps mtmd_encode + decode_with_chunks. The
+	 * AOSP shim's `eliza_llama_mtmd_describe` lands here. Backends that
+	 * only have the split encode/decode symbols implement this on top
+	 * of two FFI calls; backends with the fused symbol use one.
+	 */
+	describe(args: {
+		imageBytes: Uint8Array;
+		prompt: string;
+		maxTokens?: number;
+		temperature?: number;
+		signal?: AbortSignal;
+	}): Promise<string>;
+	/** Free the mtmd handle (and any cached encode buffers). */
+	dispose(): Promise<void>;
+}
+
+export interface LoadAospVisionBackendOptions {
+	loadArgs: VisionDescribeLoadArgs;
+	mtmdBinding?: AospLlamaMtmdBinding;
+}
+
+export async function loadAospVisionBackend(
+	opts: LoadAospVisionBackendOptions,
+): Promise<VisionDescribeBackend> {
+	const { loadArgs, mtmdBinding } = opts;
+	if (!mtmdBinding?.hasMtmd()) {
+		throw new VisionBackendUnavailableError(
+			"aosp",
+			"binding_missing_mtmd",
+			"[vision/aosp] libeliza-llama-shim does not export the mtmd symbols. The AOSP shim needs eliza_llama_mtmd_init_from_file / _encode / _describe / _free. Until the native side exports them, vision-describe on AOSP falls back to the cloud path (or stays disabled when the user opted out of cloud).",
+		);
+	}
+	if (!existsSync(loadArgs.mmprojPath)) {
+		throw new VisionBackendUnavailableError(
+			"aosp",
+			"mmproj_missing",
+			`[vision/aosp] mmproj GGUF not found: ${loadArgs.mmprojPath}`,
+		);
+	}
+	const handle = await mtmdBinding.initMtmd({
+		mmprojPath: loadArgs.mmprojPath,
+	});
+	return {
+		id: "aosp",
+		async describe(request) {
+			const { resolveImageBytes } = await import("./hash");
+			const { bytes } = resolveImageBytes(request.image);
+			const text = await handle.describe({
+				imageBytes: bytes,
+				prompt: request.prompt ?? "Describe what is in this image.",
+				maxTokens: request.maxTokens,
+				temperature: request.temperature,
+				signal: request.signal,
+			});
+			const trimmed = text.trim();
+			if (!trimmed) {
+				throw new Error("[vision/aosp] empty text from mtmd_describe");
+			}
+			const title = trimmed.split(/[.!?]/, 1)[0]?.trim() || "Image";
+			return { title, description: trimmed, cacheHit: false };
+		},
+		async dispose() {
+			await handle.dispose();
+		},
+	};
+}

package/src/services/vision/capacitor-llama.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Capacitor-llama vision-describe backend (WS2).
+ *
+ * Wraps the in-process capacitor-llama binding's multimodal projector
+ * (mtmd) surface and exposes the WS2 `VisionDescribeBackend` contract.
+ *
+ * State of the binding (2026-05-19):
+ *   `llama-cpp-capacitor`'s `LlamaContext` exposes `initMultimodal` and
+ *   `getMultimodalSupport`, which load an mmproj alongside the chat
+ *   target. The desktop bun:ffi shim does not yet bind those symbols —
+ *   the desktop FFI path returns `binding_missing_mtmd` until the shim
+ *   adds `mtmd_init_from_file` + the encode/decode helpers.
+ *
+ * What this module does today:
+ *   - Provides the WS2-shaped backend so plugin-vision / plugin-image-gen /
+ *     computer-use can compile against a stable contract.
+ *   - When the binding exposes the mtmd API, the backend dispatches
+ *     through it.
+ *   - Otherwise, the backend falls back to an injected
+ *     `VisionManagerLike` implementation when one is supplied (kept as a
+ *     pluggable seam for tests and out-of-tree integrations).
+ *   - When neither path is wired, `describe()` throws a structured
+ *     `VisionBackendUnavailableError` the arbiter surfaces upward.
+ *
+ * GPU validation status (this host has neither GPU):
+ *   The mtmd encode path is GPU-accelerated when the underlying llama.cpp
+ *   build dispatches `llama_image_t` through the model's batch path. We
+ *   document the on-device validation that's required for each GPU
+ *   family at the bottom of this file's tests (see
+ *   `__tests__/vision-describe.test.ts`). Until those run on real
+ *   hardware, GPU-backed vision is "implementation present, not
+ *   validated".
+ */
+import type { VisionDescribeBackend, VisionDescribeBackendOptions, VisionDescribeLoadArgs } from "./types";
+export declare class VisionBackendUnavailableError extends Error {
+    readonly backendId: string;
+    readonly reason: "binding_missing_mtmd" | "no_fallback_present" | "mmproj_missing";
+    readonly code = "VISION_BACKEND_UNAVAILABLE";
+    constructor(backendId: string, reason: "binding_missing_mtmd" | "no_fallback_present" | "mmproj_missing", message: string);
+}
+/**
+ * Optional shape the Capacitor-llama binding exposes once the mtmd typed
+ * wrappers land in the shared adapter. The backend only consumes
+ * `describeWithMmproj`, which wraps `LlamaContext.initMultimodal` +
+ * `completion(...)` with `media_paths`. Backends that don't satisfy this
+ * shape are treated as "binding without mtmd support" and the fallback
+ * path is used.
+ */
+export interface CapacitorLlamaMtmdBinding {
+    loadVisionModel(args: {
+        modelPath: string;
+        mmprojPath: string;
+        gpuLayers?: number | "auto" | "max";
+        contextSize?: number;
+    }): Promise<CapacitorLlamaMtmdHandle>;
+}
+export interface CapacitorLlamaMtmdHandle {
+    describeWithMmproj(args: {
+        imageBytes: Uint8Array;
+        mimeType?: string;
+        prompt: string;
+        maxTokens?: number;
+        temperature?: number;
+        signal?: AbortSignal;
+        projectedTokens?: VisionDescribeBackendOptions["projectedTokens"];
+    }): Promise<{
+        text: string;
+        projectorMs?: number;
+        decodeMs?: number;
+    }>;
+    dispose(): Promise<void>;
+}
+/**
+ * Optional VisionManager-shape fallback. Kept available as a pluggable
+ * injection point for tests and out-of-tree integrations that want to
+ * supply their own image captioning implementation.
+ */
+export interface VisionManagerLike {
+    processImage(dataUrl: string): Promise<{
+        title: string;
+        description: string;
+    }>;
+}
+export interface CapacitorLlamaVisionBackendOptions {
+    loadArgs: VisionDescribeLoadArgs;
+    /**
+     * Injected by tests and by the shared mtmd typed wrappers. When
+     * provided the backend uses the mtmd path.
+     */
+    mtmd?: CapacitorLlamaMtmdBinding;
+    /**
+     * Caption-only fallback. Optional — when present the backend uses it
+     * as last resort, after mtmd. Backends that have neither throw a
+     * structured `VisionBackendUnavailableError`.
+     */
+    visionManager?: VisionManagerLike;
+}
+export declare function loadCapacitorLlamaVisionBackend(opts: CapacitorLlamaVisionBackendOptions): Promise<VisionDescribeBackend>;
+//# sourceMappingURL=capacitor-llama.d.ts.map

package/src/services/vision/capacitor-llama.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capacitor-llama.d.ts","sourceRoot":"","sources":["capacitor-llama.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAIH,OAAO,KAAK,EACX,qBAAqB,EACrB,4BAA4B,EAC5B,sBAAsB,EAGtB,MAAM,SAAS,CAAC;AAEjB,qBAAa,6BAA8B,SAAQ,KAAK;IAGtD,QAAQ,CAAC,SAAS,EAAE,MAAM;IAC1B,QAAQ,CAAC,MAAM,EACZ,sBAAsB,GACtB,qBAAqB,GACrB,gBAAgB;IANpB,QAAQ,CAAC,IAAI,gCAAgC;gBAEnC,SAAS,EAAE,MAAM,EACjB,MAAM,EACZ,sBAAsB,GACtB,qBAAqB,GACrB,gBAAgB,EACnB,OAAO,EAAE,MAAM;CAKhB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,yBAAyB;IACzC,eAAe,CAAC,IAAI,EAAE;QACrB,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;QACpC,WAAW,CAAC,EAAE,MAAM,CAAC;KACrB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,wBAAwB;IACxC,kBAAkB,CAAC,IAAI,EAAE;QACxB,UAAU,EAAE,UAAU,CAAC;QACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,MAAM,CAAC,EAAE,WAAW,CAAC;QACrB,eAAe,CAAC,EAAE,4BAA4B,CAAC,iBAAiB,CAAC,CAAC;KAClE,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACvE,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IACjC,YAAY,CACX,OAAO,EAAE,MAAM,GACb,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACnD;AAED,MAAM,WAAW,kCAAkC;IAClD,QAAQ,EAAE,sBAAsB,CAAC;IACjC;;;OAGG;IACH,IAAI,CAAC,EAAE,yBAAyB,CAAC;IACjC;;;;OAIG;IACH,aAAa,CAAC,EAAE,iBAAiB,CAAC;CAClC;AAID,wBAAsB,+BAA+B,CACpD,IAAI,EAAE,kCAAkC,GACtC,OAAO,CAAC,qBAAqB,CAAC,CA2EhC"}