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

package/dist/services/imagegen/sd-cpp.d.ts

@@ -0,0 +1,181 @@
+/**
+ * stable-diffusion.cpp image-gen backend (WS3) — Linux + Windows
+ * (CPU/CUDA/Vulkan), and Android NDK builds reuse the same binary via
+ * `plugin-aosp-local-inference`'s JNI bridge.
+ *
+ * Why a child-process backend (and not a Node binding):
+ *
+ *   - stable-diffusion.cpp ships a single CLI binary (`sd`) per build
+ *     flavour (CPU / CUDA / Vulkan / Metal). Linking it as a Node addon
+ *     would require maintaining a parallel build matrix to llama.cpp;
+ *     we instead reuse the same binary shipped by the bundle installer.
+ *   - The CLI is stable across versions for monolithic SD checkpoints
+ *     (`--model …` / `--prompt …` / `-o …`) and split diffusion assets
+ *     (`--diffusion-model …` plus companion encoders / VAE), so contract
+ *     drift is unlikely.
+ *   - Diffusion runs in seconds, not milliseconds; the subprocess
+ *     spawn cost is negligible relative to inference time.
+ *
+ * Binary resolution order:
+ *
+ *   1. `opts.binaryPath` (test injection, explicit override).
+ *   2. `process.env.SD_CPP_BIN` (operator override).
+ *   3. `${MODELS_DIR}/bin/sd` (default install path; the bundle drops
+ *      the binary here on first activation of an image-gen tier).
+ *
+ * Availability is checked at load time by spawning the binary with
+ * `--version`. CUDA loads also require explicit capability evidence from
+ * an adjacent manifest, `--help`, or `--version`; a Linux NVIDIA GPU alone
+ * is not evidence that the installed binary was compiled with CUDA.
+ *
+ * Accelerator flags (from `ImageGenLoadArgs.accelerator`):
+ *
+ *   - `"cuda"`  → no extra flag; relies on the CUDA-built binary.
+ *   - `"vulkan"` → `--backend vulkan0` (works on AMD + Intel + NV Vulkan paths).
+ *   - `"cpu"`   → `--backend cpu --params-backend cpu` (forces CPU).
+ *   - `"auto"`  → no extra flag; the binary's own auto-detection runs.
+ *
+ * GPU validation status (this host has no GPU):
+ *   The contract here is binary surface only. CUDA / Vulkan smoke tests
+ *   run on real hardware as part of the WS5 e2e gate; documented at the
+ *   bottom of `__tests__/imagegen-handler.test.ts`.
+ *
+ * Publishing pipeline (per platform):
+ *
+ *   Linux x86_64 (CUDA):
+ *     git clone https://github.com/leejet/stable-diffusion.cpp && cd stable-diffusion.cpp \
+ *       && cmake -B build -DSD_CUDA=ON -DCMAKE_BUILD_TYPE=Release \
+ *       && cmake --build build --config Release -j
+ *     Strip + tar; sign: not required (Linux). Drop into
+ *     releases.elizaos.ai/sd-cpp/<version>/linux-x86_64-cuda/sd.tar.zst.
+ *   Linux x86_64 (Vulkan):
+ *     cmake -B build -DSD_VULKAN=ON -DCMAKE_BUILD_TYPE=Release && cmake --build build -j
+ *   Linux x86_64 (CPU):
+ *     cmake -B build -DCMAKE_BUILD_TYPE=Release && cmake --build build -j
+ *   Windows x86_64 (CUDA):
+ *     Same cmake invocation under MSVC 2022; produces sd.exe. Sign with the
+ *     Eliza Labs EV cert (signtool sign /tr ...); submit to Microsoft
+ *     SmartScreen if a new cert. Drop into releases.elizaos.ai/sd-cpp/
+ *     <version>/windows-x86_64-cuda/sd.exe.
+ *   Windows x86_64 (Vulkan, CPU): mirror the CUDA build with the matching
+ *     cmake -DSD_VULKAN=ON / -DCMAKE_BUILD_TYPE=Release flags.
+ *   Android (arm64-v8a JNI): cross-compile through the NDK against the
+ *     same upstream; not consumed directly here — `plugin-aosp-local-inference`
+ *     wraps it as `libstable-diffusion-jni.so` and the AOSP backend (see
+ *     `aosp-unavailable.ts`) calls into it via the eliza-llama-shim FFI surface.
+ *   macOS (Metal): cmake -B build -DSD_METAL=ON; codesign with the Eliza
+ *     Labs Developer ID Application cert and notarize via `xcrun notarytool
+ *     submit ...`; staple. Drop into releases.elizaos.ai/sd-cpp/<version>/
+ *     darwin-{arm64,x86_64}/sd. macOS Apple Silicon prefers `mflux` over
+ *     sd-cpp (see `mflux.ts`), but sd-cpp Metal is the fallback.
+ *   Linux riscv64 (CPU): unavailable as a shipped binary. Cross-compile via
+ *     `zig cc --target=riscv64-linux-musl` (same toolchain
+ *     packages/app-core/scripts/aosp/compile-libllama.mjs uses; see also
+ *     `native/build-omnivoice.mjs` for the omnivoice / ggml precedent).
+ *     There is no Node/host build script for sd-cpp in this repo — sd-cpp
+ *     is a child-process backend wrapping a precompiled `sd` binary
+ *     fetched from releases.elizaos.ai. Wiring riscv64 is a CDN-side
+ *     artifact addition (drop a `releases.elizaos.ai/sd-cpp/<version>/
+ *     linux-riscv64-cpu/sd` build); no build-matrix entry needs to land
+ *     here. Until then, the riscv64 binary-resolution attempt simply
+ *     surfaces the same `ImageGenBackendUnavailableError("sd-cpp", ...)`
+ *     it surfaces today on any host where the bundle installer did not
+ *     stage `sd` — i.e. image-gen is silently disabled on riscv64
+ *     (acceptable: the eliza-1 phone tier does not require image-gen).
+ */
+import { ImageGenBackendUnavailableError } from "./errors";
+import type { ImageGenBackend, ImageGenLoadArgs } from "./types";
+/**
+ * Optional test seam. Production code uses Node's `child_process.spawn`;
+ * tests inject a fake to drive deterministic outputs without forking.
+ */
+export type SdCppSpawnLike = (command: string, args: readonly string[], options?: {
+    signal?: AbortSignal;
+    cwd?: string;
+}) => {
+    stdout: AsyncIterable<Buffer> | NodeJS.ReadableStream | null;
+    stderr: AsyncIterable<Buffer> | NodeJS.ReadableStream | null;
+    on(event: "exit", listener: (code: number | null) => void): unknown;
+    on(event: "close", listener: (code: number | null) => void): unknown;
+    on(event: "error", listener: (err: Error) => void): unknown;
+    kill?(signal?: NodeJS.Signals): void;
+};
+export interface SdCppBackendOptions {
+    loadArgs: ImageGenLoadArgs;
+    /** Catalog key — copied into `ImageGenResult.metadata.model`. */
+    modelKey: string;
+    /** Override the binary path. Useful for tests. */
+    binaryPath?: string;
+    /**
+     * Override the on-disk output directory. Defaults to a fresh dir
+     * under `os.tmpdir()`. Tests can pin this so the deterministic
+     * fixture is read from a known path.
+     */
+    outputDir?: string;
+    /** Spawn implementation. Defaults to Node's `child_process.spawn`. */
+    spawnImpl?: SdCppSpawnLike;
+    /**
+     * For tests: instead of running the binary, write `fakeImageBytes`
+     * to the output file and return it. When set, `binaryPath` and
+     * version-probing are skipped.
+     */
+    fakeImageBytes?: Uint8Array;
+    /**
+     * For tests: override `Date.now` so timing assertions are stable.
+     */
+    now?: () => number;
+}
+/**
+ * Load (or in this case, "smoke-check") the sd-cpp backend. The binary
+ * lives out-of-process; "loading" is verifying it exists and runs.
+ * The actual model weights are passed per-call as either `--model <path>`
+ * or `--diffusion-model <path>`, so the same binary serves multiple
+ * GGUFs without an explicit unload step.
+ */
+export declare function loadSdCppImageGenBackend(opts: SdCppBackendOptions): Promise<ImageGenBackend>;
+interface SdCppCommandResult {
+    code: number | null;
+    stdout: string;
+    stderr: string;
+}
+type SdCppAccelerator = NonNullable<ImageGenLoadArgs["accelerator"]>;
+export interface SdCppCapabilities {
+    version: string | null;
+    accelerators: readonly SdCppAccelerator[];
+    evidence: readonly string[];
+}
+export declare function probeSdCppCapabilitiesFromBinary(binary: string, versionResult?: SdCppCommandResult, spawnImpl?: SdCppSpawnLike): Promise<SdCppCapabilities>;
+export declare function buildArgs(input: {
+    modelPath: string;
+    splitDiffusionModel?: boolean;
+    vae?: string;
+    llm?: string;
+    prompt: string;
+    negativePrompt?: string;
+    width: number;
+    height: number;
+    steps: number;
+    guidanceScale: number;
+    seed: number;
+    scheduler?: string;
+    output: string;
+    accelerator?: ImageGenLoadArgs["accelerator"];
+}): string[];
+/** 31-bit positive integer — sd-cpp stores seed as int32. */
+export declare function pickSeed(): number;
+/** Resolve a caller-supplied seed or pick a random one. */
+export declare function resolveSeed(seed: number | undefined): number;
+export declare const PNG_SIGNATURE: readonly [137, 80, 78, 71, 13, 10, 26, 10];
+/**
+ * Assert `bytes` begins with the PNG magic number. `label` is the
+ * `[imagegen/<backend>]` prefix used in the error message.
+ */
+export declare function assertPngOutput(bytes: Uint8Array, label: string, errorCode: ConstructorParameters<typeof ImageGenBackendUnavailableError>[1]): void;
+/**
+ * Wrap Node's `spawn` in the narrower `SdCppSpawnLike` shape that the
+ * subprocess backends share. The cast is centralised here so call sites
+ * don't each need their own `as unknown as` escape.
+ */
+export declare function defaultSpawn(spawnImpl: SdCppSpawnLike | undefined): SdCppSpawnLike;
+export {};
+//# sourceMappingURL=sd-cpp.d.ts.map

package/dist/services/imagegen/sd-cpp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sd-cpp.d.ts","sourceRoot":"","sources":["../../../src/services/imagegen/sd-cpp.ts"],"names":[],"mappings":"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"}

package/dist/services/imagegen/tensorrt-unavailable.d.ts

@@ -0,0 +1,83 @@
+/**
+ * TensorRT image-gen backend contract (WS3) — Windows NVIDIA.
+ *
+ * On Windows NVIDIA hosts, packaged `imagegen.exe` (built against
+ * TensorRT 10.x with the Demo Diffusion plan) is the fastest path —
+ * `nvidia/Stable-Diffusion-3.5-Medium-TensorRT` and the SDXL Turbo
+ * TensorRT plans give a 2–4× speedup over sd-cpp + CUDA on the same
+ * hardware.
+ *
+ * Why a child-process backend (and not TensorRT bindings):
+ *   - TensorRT runtime is C++; a Node binding would require shipping a
+ *     CUDA toolkit and a TensorRT runtime DLL on every Windows install,
+ *     plus rebuilding when CUDA versions change.
+ *   - The packaged `imagegen.exe` is a thin wrapper around the official
+ *     Demo Diffusion sample. The bundle installer drops it at
+ *     `${MODELS_DIR}/bin/imagegen.exe` alongside the TensorRT plan files.
+ *   - Subprocess cost is negligible relative to inference time (≈10ms
+ *     spawn vs ≈400ms inference).
+ *
+ * Binary resolution:
+ *   1. `opts.binaryPath` (test injection).
+ *   2. `process.env.IMAGEGEN_TRT_BIN` (operator override).
+ *   3. `${MODELS_DIR}/bin/imagegen.exe`.
+ *
+ * Plan file resolution:
+ *   The packaged binary expects a `--plan <path>` flag pointing at the
+ *   prebuilt TensorRT engine for the active resolution. The catalog
+ *   binds tier → plan; the installer materializes them under
+ *   `${MODELS_DIR}/imagegen/trt-plans/<modelKey>/`.
+ *
+ * Until the bundle installer + packaged binary land for Windows NVIDIA,
+ * `loadTensorRtImageGenBackend` throws `ImageGenBackendUnavailableError`
+ * and the selector falls through to sd-cpp.
+ *
+ * Publishing pipeline (Windows x86_64 NVIDIA only):
+ *
+ *   Build (`imagegen.exe`):
+ *     git clone https://github.com/NVIDIA/TensorRT && cd TensorRT/demo/Diffusion
+ *     # Build against TensorRT 10.x + CUDA 12.x
+ *     pip install -r requirements.txt
+ *     python build.py --hf-token <ci-secret> \
+ *       --version 1.5 --denoising-steps 20 \
+ *       --build-static-batch --output-dir ../../../build/imagegen-sd15
+ *     # Thin wrapper produces imagegen.exe linking against
+ *     # nvinfer_10.dll + cudart64_12.dll; pyinstaller-onefile produces a
+ *     # 35-MB executable next to the static .plan files.
+ *   Build TensorRT plan (per resolution, per model):
+ *     trtexec --onnx=unet.onnx --saveEngine=unet.plan --fp16 \
+ *       --minShapes=sample:1x4x64x64 --optShapes=sample:1x4x64x64 \
+ *       --maxShapes=sample:1x4x64x64
+ *     # Drop plan files under imagegen/trt-plans/<modelKey>/{unet,vae,clip}.plan.
+ *   Sign:
+ *     signtool sign /tr http://timestamp.digicert.com /td sha256 \
+ *       /fd sha256 /sha1 <eliza-labs-cert-thumbprint> imagegen.exe
+ *     # SmartScreen reputation builds over the first ~1000 installs;
+ *     # submit to Microsoft Defender Bytes-for-Bots if a new cert.
+ *   Drop:
+ *     releases.elizaos.ai/imagegen-trt/<version>/windows-x86_64/imagegen.exe
+ *     releases.elizaos.ai/imagegen-trt/<version>/windows-x86_64/plans/
+ *       sd-1.5-512x512/{unet,vae,clip}.plan
+ *       sdxl-turbo-1024x1024/{unet,vae,clip}.plan
+ *   The bundle installer writes the binary to
+ *   `${MODELS_DIR}/bin/imagegen.exe` and the plans under
+ *   `${MODELS_DIR}/imagegen/trt-plans/<modelKey>/`.
+ *
+ * Notarization:
+ *   N/A on Windows; SmartScreen reputation replaces the macOS notarize
+ *   step. Authenticode-signed binaries with a valid EV cert clear without
+ *   warning on first launch.
+ */
+import { type SdCppSpawnLike } from "./sd-cpp";
+import type { ImageGenBackend, ImageGenLoadArgs } from "./types";
+export interface TensorRtBackendOptions {
+    loadArgs: ImageGenLoadArgs;
+    modelKey: string;
+    binaryPath?: string;
+    outputDir?: string;
+    spawnImpl?: SdCppSpawnLike;
+    fakeImageBytes?: Uint8Array;
+    now?: () => number;
+}
+export declare function loadTensorRtImageGenBackend(opts: TensorRtBackendOptions): Promise<ImageGenBackend>;
+//# sourceMappingURL=tensorrt-unavailable.d.ts.map

package/dist/services/imagegen/tensorrt-unavailable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tensorrt-unavailable.d.ts","sourceRoot":"","sources":["../../../src/services/imagegen/tensorrt-unavailable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AAMH,OAAO,EAIN,KAAK,cAAc,EACnB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EACX,eAAe,EACf,gBAAgB,EAEhB,MAAM,SAAS,CAAC;AAEjB,MAAM,WAAW,sBAAsB;IACtC,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,cAAc,CAAC,EAAE,UAAU,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACnB;AAID,wBAAsB,2BAA2B,CAChD,IAAI,EAAE,sBAAsB,GAC1B,OAAO,CAAC,eAAe,CAAC,CAmI1B"}

package/dist/services/imagegen/types.d.ts

@@ -0,0 +1,181 @@
+/**
+ * Local image-generation (diffusion) types — WS3 deliverable.
+ *
+ * Two layers live here, mirroring the WS2 vision-describe split:
+ *
+ *   1. The **request/result** contract every WS3 backend implements
+ *      (`ImageGenRequest`, `ImageGenResult`). Callers pass a text prompt
+ *      and optional knobs; backends return PNG (or JPEG) bytes + metadata.
+ *
+ *   2. The **backend** interface (`ImageGenBackend`) that the
+ *      `MemoryArbiter` (WS1) registers as a capability handler. One
+ *      backend per per-platform diffusion runtime:
+ *
+ *        - `sd-cpp` — stable-diffusion.cpp child-process binary
+ *          (Linux + Windows + Android JNI).
+ *        - `mflux`  — MLX `mflux` Python venv (macOS Apple Silicon).
+ *        - `coreml` — Capacitor bridge to Swift `apple/ml-stable-diffusion`
+ *          (iOS only).
+ *        - `tensorrt` — packaged `imagegen.exe` / `trtexec` wrapper
+ *          (Windows NVIDIA).
+ *        - `aosp`   — bun:ffi to `eliza_llama_imagegen_*` symbols in
+ *          libeliza-llama-shim (Android JNI; unavailable until shim ships).
+ *        - `fake`   — deterministic in-process backend used by tests.
+ *
+ * All backends implement the same `load → generate → dispose` shape so the
+ * arbiter can swap between them without caring how the diffusion runtime
+ * is wired.
+ *
+ * Cache contract:
+ *
+ *   Image-gen requests do NOT go through `hashVisionInput` (that's the
+ *   WS2 projector-token cache, which lives on image *inputs*). The
+ *   request-side keying space is prompt + seed + steps + scheduler + …;
+ *   if a cache lands here later it gets its own namespace (`hashImageGenRequest`)
+ *   to avoid collisions with the WS2 vision-embedding cache. For now the
+ *   capability has no result cache — diffusion is intrinsically expensive
+ *   and most callers want a fresh sample, not a cached one.
+ */
+/** Output container the backend writes. PNG is default; JPEG is opt-in. */
+export type ImageGenMimeType = "image/png" | "image/jpeg";
+/**
+ * Caller request to `generate`. All fields except `prompt` are optional —
+ * backends apply per-runtime defaults for missing knobs.
+ *
+ * Knob semantics (consistent across backends):
+ *
+ *   - `width` / `height`: pixel resolution. Default 512×512 (SD 1.5 family) /
+ *     1024×1024 (SDXL / FLUX / Z-Image). Backends round to the nearest
+ *     multiple of 8 (SD) or 16 (SDXL) when needed.
+ *   - `steps`: denoising step count. 4 for FLUX schnell / Z-Image-Turbo
+ *     (single-pass Turbo schedulers); 20 for SD 1.5 Euler-A; 25 for SDXL.
+ *   - `guidanceScale`: classifier-free guidance. Ignored by FLUX schnell
+ *     (CFG-free). 7.5 default for SD 1.5; 4.0 default for SDXL.
+ *   - `seed`: PRNG seed. -1 / omitted → random; the backend returns the
+ *     actual seed used in `ImageGenResult.seed` so the caller can replay.
+ *   - `scheduler`: sampler name (`"euler-a"`, `"dpm++-2m"`, `"ddim"`,
+ *     `"euler"`). Backends accept the strings their underlying runtime
+ *     supports; unknown values raise `ImageGenBackendUnavailableError`.
+ */
+export interface ImageGenRequest {
+    prompt: string;
+    negativePrompt?: string;
+    width?: number;
+    height?: number;
+    steps?: number;
+    guidanceScale?: number;
+    seed?: number;
+    scheduler?: string;
+    signal?: AbortSignal;
+    /**
+     * Optional per-step progress callback. Called once per denoising step
+     * with `{ step, total }`. Backends that can't surface step-level
+     * progress (Core ML batch fused path, TensorRT static engine) MAY
+     * call this once with `step === total` at completion instead of
+     * per-step. Never required.
+     */
+    onProgressChunk?: (progress: {
+        step: number;
+        total: number;
+    }) => void;
+}
+/**
+ * Backend response. `image` is the raw bytes (PNG by default); `mime`
+ * identifies the container. The metadata block carries enough state for
+ * the caller to attach to a chat turn, log to trajectories, or feed the
+ * result back into a vision-describe for the same agent.
+ */
+export interface ImageGenResult {
+    image: Uint8Array;
+    mime: ImageGenMimeType;
+    /**
+     * The actual seed the diffusion run used. Always populated — the
+     * backend MUST resolve a random seed before sampling and report it
+     * here. This is what makes a generation reproducible.
+     */
+    seed: number;
+    metadata: {
+        /** The model id (catalog key) the run used (`"imagegen-sd-1_5-q5_0"`, etc.). */
+        model: string;
+        /** Echo of the prompt that was sampled. */
+        prompt: string;
+        /** Echo of the step count actually used (post-default-resolve). */
+        steps: number;
+        /** Echo of CFG actually applied. 0 for CFG-free models (FLUX schnell). */
+        guidanceScale: number;
+        /** End-to-end wall-clock time inside the backend. */
+        inferenceTimeMs: number;
+    };
+}
+/**
+ * Per-load arguments for an image-gen backend. The arbiter's
+ * `load(modelKey)` only carries an opaque key; the binding resolves that
+ * key to real model+vae+clip+t5 paths through this struct, which
+ * `createImageGenCapabilityRegistration` populates from the catalog +
+ * `ELIZA_1_BUNDLE_EXTRAS.json`.
+ *
+ * Some diffusion families are single-file GGUFs once quantized, such as
+ * SD 1.5 Q5_0. Others stay split: stable-diffusion.cpp runs Z-Image
+ * with `--diffusion-model` plus separate Qwen LLM text encoder and VAE
+ * files. The optional paths below carry those companion assets.
+ */
+export interface ImageGenLoadArgs {
+    /** Absolute path to the primary diffusion weights (GGUF / mlpackage / engine). */
+    modelPath: string;
+    /**
+     * Treat `modelPath` as a stable-diffusion.cpp `--diffusion-model` rather
+     * than a monolithic `--model`. Required for Z-Image/Flux-style split
+     * diffusion bundles.
+     */
+    splitDiffusionModel?: boolean;
+    /** Optional split VAE path. */
+    vae?: string;
+    /** Optional split CLIP-L / CLIP-G path. */
+    clip?: string;
+    /** Optional split T5 / Gemma text encoder path. */
+    t5?: string;
+    /** Optional split LLM text encoder path, e.g. Qwen3 for Z-Image. */
+    llm?: string;
+    /**
+     * Backend-specific acceleration hint. Accepts:
+     *   - `"auto"` (default) — let the binding decide.
+     *   - `"cpu"` — force CPU.
+     *   - `"cuda"` / `"vulkan"` / `"metal"` / `"coreml"` / `"qnn"` /
+     *     `"tensorrt"` — request a specific accelerator. Unsupported
+     *     requests fall back to `auto`.
+     */
+    accelerator?: "auto" | "cpu" | "cuda" | "vulkan" | "metal" | "coreml" | "qnn" | "tensorrt";
+    /** Cancel a slow load (model file read + weight upload). */
+    signal?: AbortSignal;
+}
+/**
+ * The contract every WS3 backend implements. The shape is intentionally
+ * narrow: the arbiter only ever calls `generate`. `dispose` is wrapped
+ * by the arbiter's `unload` so the backend can free GPU/VRAM and drop
+ * file descriptors / kill subprocesses on eviction.
+ */
+export interface ImageGenBackend {
+    /** Stable identifier — matches the backend module name. */
+    readonly id: "sd-cpp" | "mflux" | "coreml" | "tensorrt" | "aosp" | "fake";
+    /**
+     * Best-effort capability check. Implementations return `false` for
+     * requests whose `width`/`height`/`scheduler` aren't supported by
+     * the loaded weights, so the arbiter can fall through to the next
+     * registered backend (selector order). Default backends accept
+     * anything reasonable; `supports` mostly matters for `coreml`
+     * (fixed resolution per `.mlpackage`) and `tensorrt` (fixed engine
+     * shape).
+     */
+    supports(request: ImageGenRequest): boolean;
+    generate(request: ImageGenRequest): Promise<ImageGenResult>;
+    /** Release the loaded weights / subprocess. Idempotent. */
+    dispose(): Promise<void>;
+}
+/**
+ * Capability handler loader. The arbiter calls it with a model key
+ * (e.g. `"imagegen-sd-1_5-q5_0"`); the implementation resolves to a
+ * real `ImageGenLoadArgs` from `ELIZA_1_BUNDLE_EXTRAS.json` + the
+ * installed bundle and returns a live backend.
+ */
+export type ImageGenBackendLoader = (modelKey: string) => Promise<ImageGenBackend>;
+//# sourceMappingURL=types.d.ts.map

package/dist/services/imagegen/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/services/imagegen/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,2EAA2E;AAC3E,MAAM,MAAM,gBAAgB,GAAG,WAAW,GAAG,YAAY,CAAC;AAE1D;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,eAAe;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,CAAC,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;CACtE;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC9B,KAAK,EAAE,UAAU,CAAC;IAClB,IAAI,EAAE,gBAAgB,CAAC;IACvB;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE;QACT,gFAAgF;QAChF,KAAK,EAAE,MAAM,CAAC;QACd,2CAA2C;QAC3C,MAAM,EAAE,MAAM,CAAC;QACf,mEAAmE;QACnE,KAAK,EAAE,MAAM,CAAC;QACd,0EAA0E;QAC1E,aAAa,EAAE,MAAM,CAAC;QACtB,qDAAqD;QACrD,eAAe,EAAE,MAAM,CAAC;KACxB,CAAC;CACF;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,gBAAgB;IAChC,kFAAkF;IAClF,SAAS,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,+BAA+B;IAC/B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,2CAA2C;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,oEAAoE;IACpE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;;;;OAOG;IACH,WAAW,CAAC,EACT,MAAM,GACN,KAAK,GACL,MAAM,GACN,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,KAAK,GACL,UAAU,CAAC;IACd,4DAA4D;IAC5D,MAAM,CAAC,EAAE,WAAW,CAAC;CACrB;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC/B,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,CAAC;IAC1E;;;;;;;;OAQG;IACH,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC;IAC5C,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAC5D,2DAA2D;IAC3D,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AAED;;;;;GAKG;AACH,MAAM,MAAM,qBAAqB,GAAG,CACnC,QAAQ,EAAE,MAAM,KACZ,OAAO,CAAC,eAAe,CAAC,CAAC"}

package/dist/services/index.d.ts

@@ -0,0 +1,31 @@
+export type { LocalInferenceLoader } from "./active-model";
+export { assertVoiceBundleFitsHost, VoiceBundleDoesNotFitError, } from "./active-model";
+export { type BackendDecision, BackendDispatcher, type BackendId, type BackendOverride, type BackendPlan, decideBackend, ELIZA_LLM_BACKEND_ENV, type GenerateArgs as BackendGenerateArgs, type GenerateResult, type LocalInferenceBackend, litertBackendSupported, readBackendOverride, resolveCatalogForPlan, } from "./backend";
+export { ELIZA_1_PLACEHOLDER_IDS, FIRST_RUN_DEFAULT_MODEL_ID, findCatalogModel, MODEL_CATALOG, } from "./catalog";
+export { type CloudCandidate, type CloudFallbackOptions, classifyLocalError, type FallbackReason, findCloudCandidate, type LocalGenerateOutcome, makeCloudFallbackHandler, } from "./cloud-fallback";
+export { computeRuntimeContextFit, type RuntimeContextFit, type RuntimeContextFitInput, } from "./context-fit";
+export { buildDeviceResourceMetricsDevPayload, type DeviceBridgeStatus, type DeviceGenerationMetrics, type DeviceResourceMetricsDevPayload, deviceBridge, } from "./device-bridge";
+export { type BatterySummary, DeviceResourceMetrics, type DeviceResourceSummary, type DeviceThermalState, type GenerationObservation, type LowPowerSummary, type ResourceSample, type RssSummary, type ThermalSummary, type ThermalTransition, } from "./device-resource-metrics";
+export { classifyDeviceTier, DEVICE_TIER_ORDER, DEVICE_TIER_THRESHOLDS, type DeviceTier, type DeviceTierAssessment, effectiveModelMemoryGb, type RecommendedMode, TIER_WARNING_COPY, totalRamMb, } from "./device-tier";
+export { LocalInferenceEngine, localInferenceEngine, resolveIdleUnloadMs, resolveMaxConcurrentSpeculativeResponses, } from "./engine";
+export { type HandlerRegistration, handlerRegistry, type PublicRegistration, toPublicRegistration, } from "./handler-registry";
+export { assessFit, probeHardware } from "./hardware";
+export { createImageDescriptionRuntime, type ImageDescriptionRuntime, type ImageDescriptionRuntimeOptions, } from "./image-description-runtime";
+export { type CapabilityProbes, defaultsForNoBinding, type InferenceCapabilities, probeCapabilities, type ResourceSnapshot, type ThermalState, type ThermalThrottleDecision, thermalThrottleDecision, } from "./inference-capabilities";
+export { InferenceTelemetry, inferenceTelemetry, type TelemetryTags, } from "./inference-telemetry";
+export { estimateQuantizedKvBytesPerToken, KV_SPILL_MIN_CONTEXT, type KvGeometry, type KvRestoreClass, type KvSpillPlan, KvSpillUnsupportedError, planKvSpill, } from "./kv-spill";
+export { buildVoiceLatencyDevPayload, EndToEndLatencyTracer, endVoiceLatencyTurn, type HistogramSummary, LATENCY_DERIVED_KEYS, type LatencyCheckpoint, type LatencyDerived, type LatencyDerivedKey, type LatencyTrace, markVoiceLatency, type TracerOptions, VOICE_CHECKPOINTS, type VoiceCheckpoint, type VoiceLatencyDevPayload, voiceLatencyTracer, } from "./latency-trace";
+export * from "./manifest/index";
+export { type ArbiterCapability, type ArbiterEvent, type ArbiterEventListener, type ArbiterHandle, type CapabilityRegistration, getMemoryArbiter, MemoryArbiter, type MemoryArbiterOptions, setMemoryArbiter, tryGetMemoryArbiter, } from "./memory-arbiter";
+export { buildMemoryBenchmarkPlan, buildMemoryBenchmarkReport, type MemoryBenchmarkLoadResult, type MemoryBenchmarkModelPlan, type MemoryBenchmarkOptions, type MemoryBenchmarkReport, runMemoryBenchmark, summarizeMemoryBenchmark, } from "./memory-benchmark";
+export { type CapacitorPressureSource, capacitorPressureSource, compositePressureSource, type MemoryPressureEvent, type MemoryPressureLevel, type MemoryPressureListener, type MemoryPressureSource, nodeOsPressureSource, } from "./memory-pressure";
+export { type MtpDoctorCheck, type MtpDoctorCheckStatus, type MtpDoctorReport, runMtpDoctor, } from "./mtp-doctor";
+export { buildPlanActionsSkeleton, buildPlannerGuidedDecode, type PlannerAction, type PlannerGuidedDecode, planActionParameterSchema, } from "./planner-skeleton";
+export { buildTextGenerationReadiness } from "./readiness";
+export { assessCatalogModelFit, type BundleDefaultEligibility, canBundleBeDefaultOnDevice, catalogDownloadSizeBytes, catalogDownloadSizeGb, chooseSmallerFallbackModel, classifyRecommendationPlatform, deviceCapsFromProbe, type RecommendationPlatformClass, type RecommendedModelSelection, recommendForFirstRun, selectBestQuantizationVariant, selectRecommendedModelForSlot, selectRecommendedModels, } from "./recommendation";
+export { type InferenceRuntimeMode, type InferenceRuntimeModeInput, inferencePlatformClass, inferenceRuntimeMode, isCapacitorNativeRuntime, readRuntimeModeEnvOverride, type SupportedHostPlatform, } from "./runtime-target";
+export { LocalInferenceService, localInferenceService } from "./service";
+export type { ActiveModelState, CatalogModel, DownloadEvent, DownloadJob, DownloadState, HardwareFitLevel, HardwareProbe, InstalledModel, LocalInferenceDownloadStatus, LocalInferenceReadiness, LocalInferenceSlotReadiness, LocalRuntimeAcceleration, LocalRuntimeBackend, LocalRuntimeKernel, LocalRuntimeOptimizations, ModelBucket, ModelCategory, ModelHubSnapshot, TextGenerationSlot, } from "./types";
+export { VisionEmbeddingCache, type VisionEmbeddingCacheConfig, type VisionEmbeddingEntry, } from "./vision-embedding-cache";
+export * from "./voice/index";
+//# sourceMappingURL=index.d.ts.map

package/dist/services/index.d.ts.map

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