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

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

@@ -0,0 +1,134 @@
+/**
+ * AOSP image-gen backend contract (WS3) — Android via JNI.
+ *
+ * On AOSP the canonical fast path is stable-diffusion.cpp built into
+ * `libstable-diffusion-jni.so` and exposed through a JNI surface in
+ * `@elizaos/plugin-aosp-local-inference`. The shim mirrors the pattern
+ * WS2 uses for `eliza_llama_mtmd_*`: a small set of `eliza_llama_imagegen_*`
+ * symbols that bun:ffi opens via the same `dlopen` path the text-gen
+ * binding uses.
+ *
+ * Required native symbols (libeliza-llama-shim, to be added):
+ *
+ *   eliza_llama_imagegen_init_from_file(
+ *     model_path: const char *,
+ *     accelerator: const char *,   // "auto" / "vulkan" / "opencl" / "cpu"
+ *     out_handle: void **
+ *   ) -> int32  // 0 = ok; non-zero = error code
+ *
+ *   eliza_llama_imagegen_free(handle: void *) -> void
+ *
+ *   eliza_llama_imagegen_generate(
+ *     handle: void *,
+ *     prompt: const char *,
+ *     prompt_len: size_t,
+ *     negative_prompt: const char *,   // may be null
+ *     negative_prompt_len: size_t,
+ *     width: int32,
+ *     height: int32,
+ *     steps: int32,
+ *     guidance_scale: float,
+ *     seed: int64,
+ *     scheduler: const char *,         // may be null
+ *     out_png_buf: uint8_t **,         // owned by shim; valid until next call
+ *     out_png_len: size_t *,
+ *     out_seed_used: int64 *,
+ *     out_inference_ms: int64 *
+ *   ) -> int32
+ *
+ * Why a shim symbol set and not a JNI-direct stable-diffusion.cpp:
+ *   The same dlopen pattern that solves the text-gen integration solves
+ *   image-gen — we ship one `libeliza-llama-shim.so` per ABI and bun:ffi
+ *   binds against a single library handle. Doing JNI directly would
+ *   require a JVM in the AOSP build, which we don't want to mandate.
+ *
+ * Performance note for AOSP image-gen:
+ *   Vulkan is the only reasonable accelerator on Android (OpenCL is
+ *   patchy across SoCs; CPU is too slow for 4-step Z-Image-Turbo
+ *   1024×1024 — Snapdragon 8 Gen 3 hits ~6s on CPU vs ~1.4s on Vulkan).
+ *   The shim defaults to `"vulkan"` and falls back to `"cpu"` only when
+ *   Vulkan compute is unavailable.
+ *
+ * Until the shim exports the symbols above, `loadAospImageGenBackend`
+ * throws a structured `ImageGenBackendUnavailableError` so the selector
+ * can fall back to a desktop-bridge or surface "unavailable" to the UI.
+ *
+ * Publishing pipeline (Android APK + AOSP system app):
+ *
+ *   Build (libstable-diffusion-jni.so per ABI):
+ *     # cd plugins/plugin-aosp-local-inference/native
+ *     # NDK r26+ required for Vulkan compute compatibility on Snapdragon 8 Gen 3.
+ *     cmake -B build-arm64-v8a -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK_HOME/build/cmake/android.toolchain.cmake \
+ *       -DANDROID_ABI=arm64-v8a -DANDROID_PLATFORM=android-29 \
+ *       -DSD_VULKAN=ON -DBUILD_SHARED_LIBS=ON
+ *     cmake --build build-arm64-v8a -j
+ *     # Repeat for x86_64 (Cuttlefish / emulator) — see eliza/plugins/
+ *     # plugin-local-inference/native/llama.cpp patches for the JNI x86_64
+ *     # ABI surface we already maintain for text/vision.
+ *   Sign:
+ *     # AAB / APK signature; libstable-diffusion-jni.so is signed transitively
+ *     # via the app's keystore. v2 signature with the Eliza Labs production key.
+ *     bundletool build-bundle --modules=... --output=app.aab
+ *     jarsigner -keystore eliza-prod.jks -signedjar app-signed.aab app.aab eliza-key
+ *   Notarize:
+ *     N/A on Android. Google Play handles validation; AOSP system-app
+ *     installs trust the app's own keystore.
+ *   Drop:
+ *     play.google.com (split APK by ABI; sd-cpp lib lives in the
+ *     `imagegen` dynamic feature module — only downloaded after the user
+ *     opts in to image-gen).
+ *     For sideload / Cuttlefish / dev builds:
+ *     releases.elizaos.ai/aosp-imagegen/<version>/libstable-diffusion-jni-<abi>.so
+ *
+ * Why a dynamic feature module:
+ *   The Z-Image-Turbo GGUF is ~3.4 GB; bundling that into the base APK
+ *   would push the install above the Play Store's 200 MB hard cap and
+ *   trigger an automatic split. Dynamic delivery + first-launch download
+ *   keeps the base install lean and lets the user opt in.
+ */
+import type { ImageGenBackend, ImageGenLoadArgs } from "./types";
+/**
+ * The AOSP binding's image-gen surface, when present. The AOSP plugin
+ * registers an instance under the runtime service name
+ * `"aosp-llama-imagegen"` once the native shim exports the symbols
+ * above. Mirrors the WS2 `AospLlamaMtmdBinding` shape.
+ */
+export interface AospImageGenBinding {
+    /** True when libeliza-llama-shim.so exports the imagegen symbols. */
+    hasImageGen(): boolean;
+    /**
+     * Initialize a handle for the given model. The shim resolves the
+     * accelerator hint internally; pass `"auto"` to defer to its
+     * detection.
+     */
+    initImageGen(args: {
+        modelPath: string;
+        accelerator?: ImageGenLoadArgs["accelerator"];
+    }): Promise<AospImageGenHandle>;
+}
+export interface AospImageGenHandle {
+    generate(args: {
+        prompt: string;
+        negativePrompt?: string;
+        width: number;
+        height: number;
+        steps: number;
+        guidanceScale: number;
+        seed: number;
+        scheduler?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        png: Uint8Array;
+        seedUsed: number;
+        inferenceMs: number;
+    }>;
+    dispose(): Promise<void>;
+}
+export interface LoadAospImageGenBackendOptions {
+    loadArgs: ImageGenLoadArgs;
+    modelKey: string;
+    binding?: AospImageGenBinding;
+    now?: () => number;
+}
+export declare function loadAospImageGenBackend(opts: LoadAospImageGenBackendOptions): Promise<ImageGenBackend>;
+//# sourceMappingURL=aosp-unavailable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aosp-unavailable.d.ts","sourceRoot":"","sources":["../../../src/services/imagegen/aosp-unavailable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuFG;AAIH,OAAO,KAAK,EACX,eAAe,EACf,gBAAgB,EAGhB,MAAM,SAAS,CAAC;AAEjB;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IACnC,qEAAqE;IACrE,WAAW,IAAI,OAAO,CAAC;IACvB;;;;OAIG;IACH,YAAY,CAAC,IAAI,EAAE;QAClB,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,CAAC,EAAE,gBAAgB,CAAC,aAAa,CAAC,CAAC;KAC9C,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,kBAAkB;IAClC,QAAQ,CAAC,IAAI,EAAE;QACd,MAAM,EAAE,MAAM,CAAC;QACf,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;QACd,aAAa,EAAE,MAAM,CAAC;QACtB,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,MAAM,CAAC,EAAE,WAAW,CAAC;KACrB,GAAG,OAAO,CAAC;QACX,GAAG,EAAE,UAAU,CAAC;QAChB,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC;KACpB,CAAC,CAAC;IACH,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AAED,MAAM,WAAW,8BAA8B;IAC9C,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,mBAAmB,CAAC;IAC9B,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACnB;AAED,wBAAsB,uBAAuB,CAC5C,IAAI,EAAE,8BAA8B,GAClC,OAAO,CAAC,eAAe,CAAC,CAkF1B"}

package/dist/services/imagegen/backend-selector.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Image-gen backend-pick logic (WS3).
+ *
+ * Given a runtime platform + accelerator hint, return the ordered list
+ * of backend ids to try. The arbiter walks this list at load time and
+ * stops at the first backend that resolves to a live handle. A backend
+ * that throws `ImageGenBackendUnavailableError` lets the selector fall
+ * through to the next.
+ *
+ * Per-platform policy:
+ *
+ *   - **macOS Apple Silicon**: `mflux` (MLX) → `sd-cpp` (CPU fallback).
+ *     mflux is Metal-accelerated through MLX; sd-cpp-CPU is the
+ *     functional last-resort if the venv isn't installed.
+ *   - **macOS Intel**: `sd-cpp` (Metal/CPU). MLX requires Apple Silicon;
+ *     mflux is skipped on Intel Macs.
+ *   - **iOS**: `coreml` only. There is no sd-cpp on iOS — Core ML is
+ *     the only sanctioned acceleration path.
+ *   - **Linux + NVIDIA**: `sd-cpp` CUDA only when the sd-cpp probe,
+ *     binary manifest, help, or version output proves CUDA support.
+ *     Otherwise use `sd-cpp` CPU and let the loader emit an explicit
+ *     CUDA-missing fallback error if CUDA was requested elsewhere.
+ *   - **Linux + AMD/Intel**: `sd-cpp --vulkan` → `sd-cpp` (CPU fallback).
+ *   - **Linux + CPU**: `sd-cpp` (CPU).
+ *   - **Windows + NVIDIA**: `tensorrt` → `sd-cpp` (CUDA) → `sd-cpp` (CPU).
+ *   - **Windows + AMD/Intel**: `sd-cpp --vulkan` → `sd-cpp` (CPU).
+ *   - **Android (AOSP)**: `aosp` (libeliza-llama-shim with Vulkan/OpenCL,
+ *     handled by `plugin-aosp-local-inference`). No second backend on
+ *     mobile — falling back to CPU sd-cpp on a phone is too slow to be
+ *     useful and would just block the UI.
+ *
+ * The selector intentionally does NOT account for tier or model
+ * compatibility — that's the catalog's job. A 27B-tier user on a
+ * Vulkan-only Linux box doesn't change the selector; it just changes
+ * which model the chosen backend loads.
+ */
+import type { ImageGenBackend } from "./types";
+/** Per-platform runtime fingerprint the selector consumes. */
+export interface ImageGenRuntimeProfile {
+    /** Node-style `process.platform`: `"linux" | "darwin" | "win32" | "android"`. */
+    platform: NodeJS.Platform | "android" | "ios";
+    /**
+     * `process.arch` (`"x64"` | `"arm64"`). Apple Silicon = `"arm64"` on
+     * `"darwin"`. Intel Mac = `"x64"` on `"darwin"`.
+     */
+    arch: NodeJS.Architecture | string;
+    /**
+     * GPU vendor hint, when detected. `"nvidia"` enables CUDA / TensorRT
+     * paths; `"amd"` and `"intel"` favour Vulkan. `"apple"` is implied by
+     * platform=darwin+arch=arm64.
+     */
+    gpu?: "nvidia" | "amd" | "intel" | "apple" | "none";
+    /**
+     * sd-cpp binary capability evidence gathered from the first-run probe,
+     * bundle manifest, or a loader-side help/version check. GPU vendor alone
+     * is not evidence that the installed `sd` binary was built with CUDA.
+     */
+    sdCpp?: {
+        accelerators?: readonly string[];
+        cudaCapable?: boolean;
+    };
+    /**
+     * Explicit accelerator requirement for release verification and operator
+     * smoke tests. When set, the selector returns only backends that can
+     * satisfy that accelerator, so CUDA/Vulkan evidence cannot be produced by
+     * silently falling through to CPU.
+     */
+    requiredAccelerator?: "cpu" | "cuda" | "vulkan" | "metal" | "coreml" | "tensorrt";
+    /**
+     * True when running inside the iOS Capacitor shell. We can't infer
+     * from `process.platform` alone because Capacitor reports `"ios"`
+     * but Node's typings only know `darwin`/`linux`/etc.
+     */
+    isIos?: boolean;
+    /**
+     * True when running inside the Android Capacitor / `plugin-aosp-local-inference`
+     * shell. Node reports `"linux"` on AOSP, so we need an explicit signal.
+     */
+    isAndroid?: boolean;
+}
+export type ImageGenBackendId = ImageGenBackend["id"];
+/**
+ * Ordered list of `(backendId, accelerator)` pairs to try. The caller
+ * picks the first one whose backend loader returns a live handle.
+ *
+ * Accelerator strings match `ImageGenLoadArgs.accelerator`.
+ */
+export interface ImageGenBackendChoice {
+    backendId: ImageGenBackendId;
+    accelerator?: "auto" | "cpu" | "cuda" | "vulkan" | "metal" | "coreml" | "tensorrt";
+}
+export declare function selectImageGenBackends(profile: ImageGenRuntimeProfile): readonly ImageGenBackendChoice[];
+/**
+ * Tier → default image-gen model id. Mirrors
+ * `eliza/packages/chip/ELIZA_1_BUNDLE_EXTRAS.json` and the WS10 golden test's
+ * `PER_TIER_DEFAULT` map. Used by the WS3 capability registration to
+ * resolve the catalog's bare tier id into a concrete diffusion file.
+ */
+export declare const TIER_TO_DEFAULT_IMAGE_MODEL: Readonly<Record<string, {
+    modelId: string;
+    file: string;
+    splitDiffusionModel?: boolean;
+    vae?: string;
+    llm?: string;
+}>>;
+/**
+ * Resolve a tier id (or raw model id) to its default image-gen model.
+ * Returns null when the input doesn't match any known tier — caller
+ * surfaces a clear error.
+ */
+export declare function resolveDefaultImageGenModel(keyOrTier: string): {
+    modelId: string;
+    file: string;
+    splitDiffusionModel?: boolean;
+    vae?: string;
+    llm?: string;
+} | null;
+//# sourceMappingURL=backend-selector.d.ts.map

package/dist/services/imagegen/backend-selector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend-selector.d.ts","sourceRoot":"","sources":["../../../src/services/imagegen/backend-selector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,8DAA8D;AAC9D,MAAM,WAAW,sBAAsB;IACtC,iFAAiF;IACjF,QAAQ,EAAE,MAAM,CAAC,QAAQ,GAAG,SAAS,GAAG,KAAK,CAAC;IAC9C;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC,YAAY,GAAG,MAAM,CAAC;IACnC;;;;OAIG;IACH,GAAG,CAAC,EAAE,QAAQ,GAAG,KAAK,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,CAAC;IACpD;;;;OAIG;IACH,KAAK,CAAC,EAAE;QACP,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QACjC,WAAW,CAAC,EAAE,OAAO,CAAC;KACtB,CAAC;IACF;;;;;OAKG;IACH,mBAAmB,CAAC,EACjB,KAAK,GACL,MAAM,GACN,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,UAAU,CAAC;IACd;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,MAAM,iBAAiB,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;AAEtD;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACrC,SAAS,EAAE,iBAAiB,CAAC;IAC7B,WAAW,CAAC,EACT,MAAM,GACN,KAAK,GACL,MAAM,GACN,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,UAAU,CAAC;CACd;AAED,wBAAgB,sBAAsB,CACrC,OAAO,EAAE,sBAAsB,GAC7B,SAAS,qBAAqB,EAAE,CA8FlC;AAED;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CACjD,MAAM,CACL,MAAM,EACN;IACC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;CACb,CACD,CA+BD,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG;IAC/D,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;CACb,GAAG,IAAI,CASP"}

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

@@ -0,0 +1,105 @@
+/**
+ * Core ML image-gen backend contract (WS3) — iOS via Capacitor bridge.
+ *
+ * The contract for the Swift side. The real implementation lives in
+ * `eliza/packages/app-core/platforms/ios/App/App/ImageGenBridge.swift`
+ * (skeleton written under `// MARK: - Contract`). At runtime the iOS
+ * plugin (`@elizaos/plugin-ios-local-inference`) registers a Capacitor
+ * service that exposes:
+ *
+ *   await Capacitor.Plugins.ElizaImageGen.generateImage({
+ *     modelKey: "imagegen-coreml-sd-1_5",
+ *     prompt: "<text>",
+ *     negativePrompt: "<text>",   // optional
+ *     width: 512,
+ *     height: 512,
+ *     steps: 20,
+ *     guidanceScale: 7.5,
+ *     seed: 42                    // -1 = random
+ *   })
+ *     -> { png: "<base64>", seed: number, inferenceTimeMs: number }
+ *
+ * Swift side uses `apple/ml-stable-diffusion` Swift package directly;
+ * the `.mlpackage` directories are dropped into the app's Documents
+ * folder by the bundle installer.
+ *
+ * Until the Swift bridge is present and the Capacitor plugin exposes the
+ * binding, `loadCoreMlImageGenBackend` throws a structured
+ * `ImageGenBackendUnavailableError` so the selector can fall through
+ * — but on iOS there is no fall-through (sd-cpp doesn't run on iOS,
+ * mflux is macOS-only). A `coreml_unavailable` error there means
+ * "this device does not support image-gen yet."
+ *
+ * Publishing pipeline (iOS 17+ / iOS 26+):
+ *
+ *   Build (.mlpackage per tier):
+ *     git clone https://github.com/apple/ml-stable-diffusion && cd ml-stable-diffusion
+ *     python3 -m venv venv && ./venv/bin/pip install -e .
+ *     # SD 1.5 — 512x512, attention=SPLIT_EINSUM_V2 for ANE on iPhone 15+
+ *     ./venv/bin/python -m python_coreml_stable_diffusion.torch2coreml \
+ *       --convert-unet --convert-vae-encoder --convert-vae-decoder \
+ *       --convert-text-encoder --bundle-resources-for-swift-cli \
+ *       --attention-implementation SPLIT_EINSUM_V2 \
+ *       --model-version runwayml/stable-diffusion-v1-5 \
+ *       --output-dir build/sd-1.5-coreml-512
+ *     # SDXL — 1024x1024, same pipeline at --model-version
+ *     # stabilityai/sdxl-turbo for the iPhone 16 Pro / iPad M-class path.
+ *     xcrun coremlc compile build/sd-1.5-coreml-512 build/sd-1.5-coreml-512-compiled
+ *   Sign:
+ *     codesign --force --options runtime --timestamp \
+ *       --sign "Apple Distribution: Eliza Labs Inc." \
+ *       build/sd-1.5-coreml-512/*.mlpackage
+ *   Drop (into the Capacitor app bundle's on-demand resources):
+ *     Tag with `nameOfResourcesODR=ImageGenSD15` so the App Store delivers
+ *     the package only when the runtime requests it via `NSBundleResource
+ *     Request`. Total compressed .mlpackage size is ~600 MB for SD 1.5
+ *     at SPLIT_EINSUM_V2 and ~3 GB for SDXL-turbo.
+ *   Notarize / submit:
+ *     The .mlpackages ship inside the signed IPA; notarization is the
+ *     standard `altool notarytool submit` step for the host IPA.
+ *   iOS 26 (forward-compat note):
+ *     iOS 26 adds the public `MLTensor` API and an updated ANE driver;
+ *     re-build the .mlpackage with `--attention-implementation
+ *     SPLIT_EINSUM_V2` on the iOS 26 SDK to pick up the latest ANE
+ *     scheduling improvements. The Swift bridge code in
+ *     `ImageGenBridge.swift` is the same across iOS 17/18/26.
+ */
+import type { ImageGenBackend, ImageGenLoadArgs } from "./types";
+/**
+ * The Capacitor bridge shape. The iOS plugin registers an instance
+ * under the runtime service name `"capacitor-image-gen"` once the
+ * Swift side ships.
+ */
+export interface CoreMlImageGenBridge {
+    /**
+     * True when the Swift `ImageGenBridge.swift` is present AND a
+     * `.mlpackage` has been resolved for the active tier. False when
+     * either is missing — the backend throws on `generate` in
+     * that case rather than producing a synthetic PNG.
+     */
+    isAvailable(): boolean;
+    generateImage(args: {
+        modelKey: string;
+        prompt: string;
+        negativePrompt?: string;
+        width: number;
+        height: number;
+        steps: number;
+        guidanceScale: number;
+        seed: number;
+        signal?: AbortSignal;
+    }): Promise<{
+        /** Base64-encoded PNG. */
+        png: string;
+        seed: number;
+        inferenceTimeMs: number;
+    }>;
+}
+export interface LoadCoreMlImageGenBackendOptions {
+    loadArgs: ImageGenLoadArgs;
+    modelKey: string;
+    bridge?: CoreMlImageGenBridge;
+    now?: () => number;
+}
+export declare function loadCoreMlImageGenBackend(opts: LoadCoreMlImageGenBackendOptions): Promise<ImageGenBackend>;
+//# sourceMappingURL=coreml-unavailable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"coreml-unavailable.d.ts","sourceRoot":"","sources":["../../../src/services/imagegen/coreml-unavailable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AAIH,OAAO,KAAK,EACX,eAAe,EACf,gBAAgB,EAGhB,MAAM,SAAS,CAAC;AAEjB;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACpC;;;;;OAKG;IACH,WAAW,IAAI,OAAO,CAAC;IACvB,aAAa,CAAC,IAAI,EAAE;QACnB,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;QACd,aAAa,EAAE,MAAM,CAAC;QACtB,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,CAAC,EAAE,WAAW,CAAC;KACrB,GAAG,OAAO,CAAC;QACX,0BAA0B;QAC1B,GAAG,EAAE,MAAM,CAAC;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,eAAe,EAAE,MAAM,CAAC;KACxB,CAAC,CAAC;CACH;AAED,MAAM,WAAW,gCAAgC;IAChD,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAC9B,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACnB;AAED,wBAAsB,yBAAyB,CAC9C,IAAI,EAAE,gCAAgC,GACpC,OAAO,CAAC,eAAe,CAAC,CA4F1B"}

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

@@ -0,0 +1,16 @@
+/**
+ * Structured error every WS3 backend throws when it can't serve a
+ * request. Mirrors `VisionBackendUnavailableError` so the arbiter / WS3
+ * provider handler can surface a single typed failure mode upward.
+ */
+export declare class ImageGenBackendUnavailableError extends Error {
+    readonly backendId: string;
+    readonly reason: "binary_missing" | "binary_version_mismatch" | "cuda_binary_missing" | "vulkan_binary_missing" | "metal_binary_missing" | "cuda_unavailable" | "model_missing" | "binding_unavailable" | "unsupported_runtime" | "unsupported_request" | "subprocess_failed";
+    readonly code = "IMAGE_GEN_BACKEND_UNAVAILABLE";
+    constructor(backendId: string, reason: "binary_missing" | "binary_version_mismatch" | "cuda_binary_missing" | "vulkan_binary_missing" | "metal_binary_missing" | "cuda_unavailable" | "model_missing" | "binding_unavailable" | "unsupported_runtime" | "unsupported_request" | "subprocess_failed", message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** Tells callers whether a thrown error came from a backend availability check. */
+export declare function isImageGenUnavailable(err: unknown): err is ImageGenBackendUnavailableError;
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/services/imagegen/errors.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qBAAa,+BAAgC,SAAQ,KAAK;IAGxD,QAAQ,CAAC,SAAS,EAAE,MAAM;IAC1B,QAAQ,CAAC,MAAM,EACZ,gBAAgB,GAChB,yBAAyB,GACzB,qBAAqB,GACrB,uBAAuB,GACvB,sBAAsB,GACtB,kBAAkB,GAClB,eAAe,GACf,qBAAqB,GACrB,qBAAqB,GACrB,qBAAqB,GACrB,mBAAmB;IAdvB,QAAQ,CAAC,IAAI,mCAAmC;gBAEtC,SAAS,EAAE,MAAM,EACjB,MAAM,EACZ,gBAAgB,GAChB,yBAAyB,GACzB,qBAAqB,GACrB,uBAAuB,GACvB,sBAAsB,GACtB,kBAAkB,GAClB,eAAe,GACf,qBAAqB,GACrB,qBAAqB,GACrB,qBAAqB,GACrB,mBAAmB,EACtB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAK9B;AAED,mFAAmF;AACnF,wBAAgB,qBAAqB,CACpC,GAAG,EAAE,OAAO,GACV,GAAG,IAAI,+BAA+B,CAOxC"}

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

@@ -0,0 +1,58 @@
+/**
+ * Local image-generation capability (WS3) — public entry point.
+ *
+ * This module is what `provider.ts` (`createImageGenerationHandler`),
+ * the UI image-gen action, and image-gen skill imports to
+ * register the capability with the WS1 MemoryArbiter.
+ *
+ * Wiring:
+ *
+ *   const arbiter = service.getMemoryArbiter();
+ *   const registration = createImageGenCapabilityRegistration({
+ *     loader: createDefaultImageGenLoader({ ... }),
+ *   });
+ *   arbiter.registerCapability(registration);
+ *
+ * `createImageGenCapabilityRegistration` wraps the underlying backend
+ * so the arbiter's `run(request)` path:
+ *
+ *   1. Calls `backend.supports(request)`. If false, the arbiter throws
+ *      `unsupported_request` so the caller can pick a different tier
+ *      or surface a clear error.
+ *   2. Calls `backend.generate(request)` and returns the result.
+ *
+ * The capability registers with `residentRole: "vision"` so image-gen
+ * co-evicts with vision-describe — both are GPU-heavy weights with
+ * comparable RAM footprints, and the arbiter's existing one-model-per-
+ * role policy gives us free serialization. A vision-describe request
+ * arriving while image-gen is in flight will queue, wait for the
+ * generate to drain, then evict the diffusion weights and load the
+ * VL weights.
+ */
+export { type AospImageGenBinding, type AospImageGenHandle, type LoadAospImageGenBackendOptions, loadAospImageGenBackend, } from "./aosp-unavailable";
+export { type ImageGenBackendChoice, type ImageGenBackendId, type ImageGenRuntimeProfile, resolveDefaultImageGenModel, selectImageGenBackends, TIER_TO_DEFAULT_IMAGE_MODEL, } from "./backend-selector";
+export { type CoreMlImageGenBridge, type LoadCoreMlImageGenBackendOptions, loadCoreMlImageGenBackend, } from "./coreml-unavailable";
+export { ImageGenBackendUnavailableError, isImageGenUnavailable, } from "./errors";
+export { loadMfluxImageGenBackend, type MfluxBackendOptions, } from "./mflux";
+export { assertPngOutput, defaultSpawn, loadSdCppImageGenBackend, PNG_SIGNATURE, pickSeed, resolveSeed, type SdCppBackendOptions, type SdCppSpawnLike, } from "./sd-cpp";
+export { loadTensorRtImageGenBackend, type TensorRtBackendOptions, } from "./tensorrt-unavailable";
+export type { ImageGenBackend, ImageGenBackendLoader, ImageGenLoadArgs, ImageGenMimeType, ImageGenRequest, ImageGenResult, } from "./types";
+import type { CapabilityRegistration } from "../memory-arbiter";
+import type { ImageGenBackend, ImageGenBackendLoader, ImageGenRequest, ImageGenResult } from "./types";
+export interface CreateImageGenCapabilityRegistrationOptions {
+    loader: ImageGenBackendLoader;
+    /**
+     * Best-effort RAM/VRAM footprint estimate for the loaded weights. The
+     * arbiter only uses this for telemetry; eviction is by priority. The
+     * default (3500 MB) matches Z-Image-Turbo Q4_K_M; small-tier SD 1.5
+     * loaders SHOULD pass ~1100.
+     */
+    estimatedMb?: number;
+}
+/**
+ * Build a `CapabilityRegistration` ready to feed to
+ * `arbiter.registerCapability()`. Mirrors
+ * `createVisionCapabilityRegistration` from WS2.
+ */
+export declare function createImageGenCapabilityRegistration(opts: CreateImageGenCapabilityRegistrationOptions): CapabilityRegistration<ImageGenBackend, ImageGenRequest, ImageGenResult>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/imagegen/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EACN,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,8BAA8B,EACnC,uBAAuB,GACvB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACN,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,EAC3B,2BAA2B,EAC3B,sBAAsB,EACtB,2BAA2B,GAC3B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACN,KAAK,oBAAoB,EACzB,KAAK,gCAAgC,EACrC,yBAAyB,GACzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACN,+BAA+B,EAC/B,qBAAqB,GACrB,MAAM,UAAU,CAAC;AAClB,OAAO,EACN,wBAAwB,EACxB,KAAK,mBAAmB,GACxB,MAAM,SAAS,CAAC;AACjB,OAAO,EACN,eAAe,EACf,YAAY,EACZ,wBAAwB,EACxB,aAAa,EACb,QAAQ,EACR,WAAW,EACX,KAAK,mBAAmB,EACxB,KAAK,cAAc,GACnB,MAAM,UAAU,CAAC;AAClB,OAAO,EACN,2BAA2B,EAC3B,KAAK,sBAAsB,GAC3B,MAAM,wBAAwB,CAAC;AAChC,YAAY,EACX,eAAe,EACf,qBAAqB,EACrB,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EACf,cAAc,GACd,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,EAEX,sBAAsB,EACtB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EACX,eAAe,EACf,qBAAqB,EACrB,eAAe,EACf,cAAc,EACd,MAAM,SAAS,CAAC;AAEjB,MAAM,WAAW,2CAA2C;IAC3D,MAAM,EAAE,qBAAqB,CAAC;IAC9B;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,wBAAgB,oCAAoC,CACnD,IAAI,EAAE,2CAA2C,GAC/C,sBAAsB,CAAC,eAAe,EAAE,eAAe,EAAE,cAAc,CAAC,CA+B1E"}

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

@@ -0,0 +1,74 @@
+/**
+ * MLX-mflux image-gen backend (WS3) — macOS Apple Silicon.
+ *
+ * `mflux` is the community MLX port of FLUX.1 with Z-Image-Turbo support
+ * (https://github.com/filipstrand/mflux). It's a Python package that
+ * ships a `mflux-generate` CLI; we shell out to it from a venv the
+ * bundle installer creates at `${MODELS_DIR}/mlx/mflux`.
+ *
+ * Why a venv (and not a Node MLX binding):
+ *   - MLX Python is the canonical fast path on Apple Silicon — the
+ *     mflux maintainers track upstream MLX optimizations directly.
+ *   - There is no stable MLX Node binding today; writing one would
+ *     duplicate MLX Python's surface for very little gain. Diffusion
+ *     latency dominates the IPC cost.
+ *   - The mflux CLI is stable, with `--model …`, `--prompt …`,
+ *     `--steps …`, `--seed …`, `--output …`.
+ *
+ * Venv resolution:
+ *   1. `opts.binaryPath` (test injection).
+ *   2. `process.env.MFLUX_BIN` (operator override; usually the venv's
+ *      `bin/mflux-generate`).
+ *   3. `${MODELS_DIR}/mlx/mflux/bin/mflux-generate`.
+ *
+ * Model resolution:
+ *   mflux expects `--model` to be either a HuggingFace repo id
+ *   (`black-forest-labs/FLUX.1-schnell`) or a local checkpoint
+ *   directory. The bundle installer writes the local path; we pass it
+ *   verbatim.
+ *
+ * GPU validation status:
+ *   On Apple Silicon this hits the Metal Performance Shaders backend
+ *   through MLX. We have no Mac on this host — see
+ *   `__tests__/imagegen-handler.test.ts` notes for the on-device check
+ *   (M2 / M3 Max smoke for Z-Image-Turbo 4-step <2s 1024×1024).
+ *
+ * Publishing pipeline (macOS Apple Silicon only — Intel Mac falls back to
+ * sd-cpp Metal, see `sd-cpp.ts`):
+ *
+ *   Build:
+ *     python3 -m venv ${MODELS_DIR}/mlx/mflux
+ *     ${MODELS_DIR}/mlx/mflux/bin/pip install --upgrade pip
+ *     ${MODELS_DIR}/mlx/mflux/bin/pip install mflux           # arm64-only wheel
+ *   Sign:
+ *     codesign --force --options runtime --timestamp \
+ *       --sign "Developer ID Application: Eliza Labs Inc." \
+ *       ${MODELS_DIR}/mlx/mflux/bin/python3
+ *     codesign --force --options runtime --timestamp \
+ *       --sign "Developer ID Application: Eliza Labs Inc." \
+ *       ${MODELS_DIR}/mlx/mflux/bin/mflux-generate
+ *   Notarize:
+ *     ditto -c -k --keepParent ${MODELS_DIR}/mlx/mflux mflux-venv.zip
+ *     xcrun notarytool submit mflux-venv.zip \
+ *       --apple-id <ci-secret> --team-id <eliza-labs-team> --wait
+ *     xcrun stapler staple ${MODELS_DIR}/mlx/mflux/bin/mflux-generate
+ *   Drop:
+ *     releases.elizaos.ai/mflux/<version>/darwin-arm64/mflux-venv.tar.zst
+ *   The bundle installer untars the venv into the user's `${MODELS_DIR}/
+ *   mlx/mflux/` directory; the first launch runs `mflux-generate --help`
+ *   to warm up the cache.
+ */
+import { type SdCppSpawnLike } from "./sd-cpp";
+import type { ImageGenBackend, ImageGenLoadArgs } from "./types";
+export interface MfluxBackendOptions {
+    loadArgs: ImageGenLoadArgs;
+    modelKey: string;
+    binaryPath?: string;
+    outputDir?: string;
+    spawnImpl?: SdCppSpawnLike;
+    /** Test seam — when set, skips subprocess and writes these bytes. */
+    fakeImageBytes?: Uint8Array;
+    now?: () => number;
+}
+export declare function loadMfluxImageGenBackend(opts: MfluxBackendOptions): Promise<ImageGenBackend>;
+//# sourceMappingURL=mflux.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mflux.d.ts","sourceRoot":"","sources":["../../../src/services/imagegen/mflux.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAMH,OAAO,EAIN,KAAK,cAAc,EACnB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EACX,eAAe,EACf,gBAAgB,EAGhB,MAAM,SAAS,CAAC;AAEjB,MAAM,WAAW,mBAAmB;IACnC,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,qEAAqE;IACrE,cAAc,CAAC,EAAE,UAAU,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACnB;AAID,wBAAsB,wBAAwB,CAC7C,IAAI,EAAE,mBAAmB,GACvB,OAAO,CAAC,eAAe,CAAC,CA8H1B"}