@elizaos/app-core 2.0.0-beta.3 → 2.0.3-beta.3

package/scripts/omnivoice-fuse/prepare.mjs

@@ -3,13 +3,13 @@
  * and copy `src/` + `tools/` + selected `examples/` data into the
  * llama.cpp tree under `<llamaCppRoot>/omnivoice/`.
  *
- * Caller (build-llama-cpp-dflash.mjs):
+ * Caller (build-llama-cpp-mtp.mjs):
  *   import { prepareOmnivoiceFusion } from
  *     "./omnivoice-fuse/prepare.mjs";
  *   const { commit, ggmlSubmoduleCommit, sourceCount } =
  *     prepareOmnivoiceFusion({
- *       cacheRoot: "...", // ~/.cache/eliza-dflash
- *       llamaCppRoot: "...", // path to milady-ai/llama.cpp checkout
+ *       cacheRoot: "...", // ~/.cache/eliza-mtp
+ *       llamaCppRoot: "...", // path to elizaOS/llama.cpp checkout
  *       omnivoiceRef: "38f824023d…",
  *     });
  *
@@ -22,24 +22,38 @@ import fs from "node:fs";
 import path from "node:path";
 
 const OMNIVOICE_REPO =
-  process.env.MILADY_OMNIVOICE_REMOTE ||
-  "https://github.com/ServeurpersoCom/omnivoice.cpp.git";
+  process.env.ELIZA_OMNIVOICE_REMOTE ||
+  "https://github.com/elizaOS/omnivoice.cpp.git";
 
 // Master HEAD as of 2026-05-10. Bump per the runbook in README.md.
 export const OMNIVOICE_REF =
-  process.env.MILADY_OMNIVOICE_REF || "38f824023d12b21a7c324651b18bd90f16d8bb86";
+  process.env.ELIZA_OMNIVOICE_REF || "38f824023d12b21a7c324651b18bd90f16d8bb86";
 
 // The ServeurpersoCom ggml submodule pin we explicitly DO NOT include
 // in the fused build. Recorded so verify-symbols.mjs can assert that no
 // `omnivoice/ggml` directory is left dangling under the llama.cpp tree.
 export const OMNIVOICE_GGML_REF =
-  process.env.MILADY_OMNIVOICE_GGML_REF ||
+  process.env.ELIZA_OMNIVOICE_GGML_REF ||
   "0e3980ef205ea3639650f59e54cfeecd7d947700";
 
 // Subdirectory inside the llama.cpp checkout where omnivoice sources
 // land. Stable so the CMake graft and the symbol verifier agree.
 export const OMNIVOICE_GRAFT_SUBDIR = "omnivoice";
 
+const REQUIRED_PUBLIC_OMNIVOICE_SYMBOLS = Object.freeze([
+  "ov_version",
+  "ov_last_error",
+  "ov_audio_free",
+  "ov_init_default_params",
+  "ov_tts_default_params",
+  "ov_init",
+  "ov_free",
+  "ov_log_set",
+  "ov_synthesize",
+  "ov_encode_reference",
+  "ov_duration_sec_to_tokens",
+]);
+
 function run(cmd, args, opts = {}) {
   const result = spawnSync(cmd, args, {
     stdio: opts.capture ? ["ignore", "pipe", "pipe"] : "inherit",
@@ -52,23 +66,2142 @@ function run(cmd, args, opts = {}) {
       ? `\nstdout:\n${result.stdout || ""}\nstderr:\n${result.stderr || ""}`
       : "";
     throw new Error(
-      `[omnivoice-fuse] ${cmd} ${args.join(" ")} failed with ${result.status}${detail}`,
+      `[omnivoice-fuse] ${cmd} ${args.join(" ")} failed with ${result.status}${detail}`,
+    );
+  }
+  return result.stdout?.trim() ?? "";
+}
+
+function copyDirRecursive(src, dst) {
+  fs.mkdirSync(dst, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const from = path.join(src, entry.name);
+    const to = path.join(dst, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(from, to);
+    } else if (entry.isFile() || entry.isSymbolicLink()) {
+      fs.copyFileSync(from, to);
+    }
+  }
+}
+
+function replaceBetween(source, startMarker, endMarker, replacement) {
+  const start = source.indexOf(startMarker);
+  if (start < 0) {
+    throw new Error(
+      `[omnivoice-fuse] compatibility patch anchor not found: ${startMarker}`,
+    );
+  }
+  const end = source.indexOf(endMarker, start);
+  if (end < 0) {
+    throw new Error(
+      `[omnivoice-fuse] compatibility patch end anchor not found: ${endMarker}`,
+    );
+  }
+  return source.slice(0, start) + replacement + source.slice(end);
+}
+
+function writeElizaFfiAdapter({ graftRoot, commit }) {
+  const ffiHeaderSrc = new URL("./ffi.h", import.meta.url).pathname;
+  const ffiHeaderDst = path.join(graftRoot, "src", "ffi.h");
+  fs.copyFileSync(ffiHeaderSrc, ffiHeaderDst);
+  fs.writeFileSync(
+    path.join(graftRoot, "src", "eliza-inference-ffi.cpp"),
+    `// Generated by omnivoice-fuse/prepare.mjs.
+// C ABI bridge between libelizainference and omnivoice.cpp.
+
+#include "ffi.h"
+#include "omnivoice.h"
+#include "llama.h"
+#include "mtmd.h"
+#include "mtmd-helper.h"
+
+#include <algorithm>
+#include <atomic>
+#include <cerrno>
+#include <cctype>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <filesystem>
+#include <fstream>
+#include <memory>
+#include <mutex>
+#include <new>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+/* OmniVoice voice-preset payload parsed from
+ * <bundle_dir>/cache/voice-preset-<id>.bin (ELZ2 v2 binary format). v1
+ * presets (Kokoro-style: embedding + phrase-cache seed only) parse with
+ * empty ref_audio_tokens / ref_text / instruct fields so the C side
+ * falls back to OmniVoice's auto-voice path on those entries.
+ *
+ * The format is described in TypeScript at
+ * plugins/plugin-local-inference/src/services/voice/voice-preset-format.ts.
+ * This C-side parser is a slim, read-only mirror of that contract — it
+ * understands both v1 and v2, returns false on any structural error,
+ * and never copies large buffers (ref_audio_tokens is a 24 KB span at
+ * most for a 30 s reference). */
+struct EliVoicePreset {
+    std::string voice_id;
+    std::string instruct;
+    std::string ref_text;
+    std::vector<int32_t> ref_audio_tokens;
+    int K = 0;
+    int ref_T = 0;
+    int version = 0;
+    bool empty_payload = true;
+};
+
+struct EliInferenceContext {
+    std::string bundle_dir;
+    std::string tts_model_path;
+    std::string codec_model_path;
+    std::string asr_model_path;
+    std::string asr_mmproj_path;
+    ov_context * ov = nullptr;
+    llama_model * asr_model = nullptr;
+    llama_context * asr_lctx = nullptr;
+    mtmd_context * asr_mtmd = nullptr;
+    llama_sampler * asr_sampler = nullptr;
+    int asr_sample_rate = 0;
+    int asr_n_batch = 512;
+    std::atomic<bool> tts_cancel{false};
+    std::mutex tts_mutex;
+    std::mutex asr_mutex;
+    /* Streaming-LLM text model, loaded lazily on the first
+     * eliza_inference_llm_stream_open and shared across sessions. */
+    std::string llm_model_path;
+    llama_model * llm_model = nullptr;
+    std::mutex llm_mutex;
+    /* Parsed voice presets, keyed by voice id. Populated lazily on the
+     * first TTS call that mentions the id. The mutex protects the map
+     * itself; presets are immutable once inserted. */
+    std::mutex preset_mutex;
+    std::unordered_map<std::string, EliVoicePreset> presets;
+};
+
+/* ELZ2 magic 'ELZ1' (the ascii bytes 'E','L','Z','1' little-endian).
+ * The magic stays 'ELZ1' across format versions — only the version
+ * word at offset 4 changes between v1 and v2. */
+static constexpr uint32_t ELIZA_VOICE_PRESET_MAGIC = 0x315A4C45u;
+
+static inline uint32_t eliza_le_u32(const uint8_t * p) {
+    return (uint32_t)p[0] | ((uint32_t)p[1] << 8) |
+           ((uint32_t)p[2] << 16) | ((uint32_t)p[3] << 24);
+}
+
+static inline int32_t eliza_le_i32(const uint8_t * p) {
+    return (int32_t) eliza_le_u32(p);
+}
+
+/* Validated voice-id allowlist: a single path-safe segment (mirrors the
+ * TypeScript voicePresetPath check). Refuses anything containing '/'
+ * '..' or characters outside [A-Za-z0-9._-]. */
+static bool eliza_is_safe_voice_id(const std::string & id) {
+    if (id.empty()) return false;
+    if (id.find("..") != std::string::npos) return false;
+    for (char c : id) {
+        const bool ok =
+            (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
+            (c >= '0' && c <= '9') || c == '.' || c == '_' || c == '-';
+        if (!ok) return false;
+    }
+    return true;
+}
+
+/* Read a whole file into memory. Returns true on success. */
+static bool eliza_read_file_bytes(const std::filesystem::path & path,
+                                  std::vector<uint8_t> & out) {
+    std::ifstream f(path, std::ios::binary);
+    if (!f.good()) return false;
+    f.seekg(0, std::ios::end);
+    std::streamsize sz = f.tellg();
+    if (sz < 0) return false;
+    out.resize((size_t) sz);
+    if (sz == 0) return true;
+    f.seekg(0, std::ios::beg);
+    f.read(reinterpret_cast<char *>(out.data()), sz);
+    return f.good() || f.eof();
+}
+
+/* Parse an ELZ2 voice-preset blob (also accepts v1 — v2-only fields
+ * stay empty). Returns false on any structural error. */
+static bool eliza_parse_voice_preset(const std::vector<uint8_t> & bytes,
+                                     EliVoicePreset & out,
+                                     std::string & err) {
+    if (bytes.size() < 24) {
+        err = "voice preset truncated: header < 24 bytes";
+        return false;
+    }
+    const uint8_t * p = bytes.data();
+    const size_t len = bytes.size();
+    const uint32_t magic = eliza_le_u32(p);
+    if (magic != ELIZA_VOICE_PRESET_MAGIC) {
+        err = "voice preset bad magic";
+        return false;
+    }
+    const uint32_t version = eliza_le_u32(p + 4);
+    if (version != 1u && version != 2u) {
+        err = "voice preset unsupported version";
+        return false;
+    }
+    out.version = (int) version;
+
+    /* v1 has a 24-byte header (embedding section + phrase section). v2
+     * has a 64-byte header that ADDS ref_audio_tokens / ref_text /
+     * instruct / metadata section descriptors. We only care about the
+     * v2 sections — the embedding + phrase seed are handled in JS. */
+    if (version == 1u) {
+        /* v1: nothing the C side needs (embedding is fp32 for Kokoro
+         * etc., not OmniVoice). Mark empty and return OK. */
+        out.empty_payload = true;
+        return true;
+    }
+    if (len < 64) {
+        err = "voice preset v2 truncated header";
+        return false;
+    }
+    auto section_at = [&](size_t hdr_off, uint32_t & off, uint32_t & sz) {
+        off = eliza_le_u32(p + hdr_off);
+        sz = eliza_le_u32(p + hdr_off + 4);
+    };
+    uint32_t ref_tok_off = 0, ref_tok_sz = 0;
+    uint32_t ref_txt_off = 0, ref_txt_sz = 0;
+    uint32_t instr_off = 0, instr_sz = 0;
+    section_at(24, ref_tok_off, ref_tok_sz);
+    section_at(32, ref_txt_off, ref_txt_sz);
+    section_at(40, instr_off, instr_sz);
+    /* metadata at +48/+52 — we don't consume it on the C side. */
+
+    auto bounds_ok = [&](uint32_t off, uint32_t sz) {
+        if (sz == 0) return true;
+        if (off < 64) return false;
+        const size_t end = (size_t) off + (size_t) sz;
+        return end <= len;
+    };
+    if (!bounds_ok(ref_tok_off, ref_tok_sz) ||
+        !bounds_ok(ref_txt_off, ref_txt_sz) ||
+        !bounds_ok(instr_off, instr_sz)) {
+        err = "voice preset section out of bounds";
+        return false;
+    }
+
+    if (ref_tok_sz > 0) {
+        if (ref_tok_sz < 8) {
+            err = "voice preset ref_audio_tokens truncated";
+            return false;
+        }
+        const uint8_t * rt = p + ref_tok_off;
+        const uint32_t K = eliza_le_u32(rt);
+        const uint32_t refT = eliza_le_u32(rt + 4);
+        const size_t payload = ref_tok_sz - 8;
+        if (payload != (size_t) K * (size_t) refT * 4u) {
+            err = "voice preset ref_audio_tokens shape mismatch";
+            return false;
+        }
+        out.K = (int) K;
+        out.ref_T = (int) refT;
+        out.ref_audio_tokens.resize((size_t) K * (size_t) refT);
+        for (size_t i = 0; i < out.ref_audio_tokens.size(); ++i) {
+            out.ref_audio_tokens[i] = eliza_le_i32(rt + 8 + i * 4u);
+        }
+    }
+    if (ref_txt_sz > 0) {
+        out.ref_text.assign(reinterpret_cast<const char *>(p + ref_txt_off),
+                            (size_t) ref_txt_sz);
+    }
+    if (instr_sz > 0) {
+        out.instruct.assign(reinterpret_cast<const char *>(p + instr_off),
+                            (size_t) instr_sz);
+    }
+    out.empty_payload =
+        out.instruct.empty() && out.ref_text.empty() && out.ref_audio_tokens.empty();
+    return true;
+}
+
+/* Resolve a preset id to a parsed preset. Returns nullptr if the id is
+ * unsafe, the file is missing, or parsing fails — in those cases the
+ * caller falls back to OmniVoice auto-voice (params.instruct = "")
+ * after logging via out_error.
+ *
+ * On a cache hit the cached preset is returned without re-reading the
+ * file. The preset table is keyed by voice id and lives on the
+ * EliInferenceContext, so two different contexts (different bundles)
+ * load independent presets.
+ *
+ * Caller must hold ctx->preset_mutex (or otherwise serialize). */
+static const EliVoicePreset * eliza_load_voice_preset_locked(
+    EliInferenceContext * ctx,
+    const std::string & voice_id,
+    std::string & err) {
+    auto it = ctx->presets.find(voice_id);
+    if (it != ctx->presets.end()) return &it->second;
+
+    if (!eliza_is_safe_voice_id(voice_id)) {
+        err = "voice preset id is not a safe single segment: " + voice_id;
+        return nullptr;
+    }
+    std::filesystem::path file =
+        std::filesystem::path(ctx->bundle_dir) / "cache" /
+        ("voice-preset-" + voice_id + ".bin");
+    std::error_code ec;
+    if (!std::filesystem::is_regular_file(file, ec)) {
+        err = "voice preset file not found: " + file.string();
+        return nullptr;
+    }
+    std::vector<uint8_t> bytes;
+    if (!eliza_read_file_bytes(file, bytes)) {
+        err = "voice preset file unreadable: " + file.string();
+        return nullptr;
+    }
+    EliVoicePreset preset;
+    preset.voice_id = voice_id;
+    if (!eliza_parse_voice_preset(bytes, preset, err)) {
+        return nullptr;
+    }
+    auto ins = ctx->presets.emplace(voice_id, std::move(preset));
+    return &ins.first->second;
+}
+
+/* Apply a resolved preset to an ov_tts_params struct. Sets instruct,
+ * ref_audio_tokens, ref_T, ref_text from the preset. Leaves
+ * ref_audio_24k / ref_n_samples alone — they are only used by the
+ * encode entrypoint, not synthesis. */
+static void eliza_apply_preset_to_params(const EliVoicePreset & preset,
+                                         ov_tts_params * params) {
+    if (!preset.instruct.empty()) {
+        params->instruct = preset.instruct.c_str();
+    }
+    if (!preset.ref_audio_tokens.empty() && preset.K > 0 && preset.ref_T > 0) {
+        params->ref_audio_tokens = preset.ref_audio_tokens.data();
+        params->ref_T = preset.ref_T;
+    }
+    if (!preset.ref_text.empty()) {
+        params->ref_text = preset.ref_text.c_str();
+    }
+}
+
+#define ELIZA_STRINGIFY_IMPL(x) #x
+#define ELIZA_STRINGIFY(x) ELIZA_STRINGIFY_IMPL(x)
+
+static char * eliza_strdup(const std::string & s) {
+    char * out = (char *) std::malloc(s.size() + 1);
+    if (!out) return nullptr;
+    std::memcpy(out, s.c_str(), s.size() + 1);
+    return out;
+}
+
+static void eliza_set_error(char ** out_error, const std::string & msg) {
+    if (!out_error) return;
+    *out_error = eliza_strdup(msg);
+}
+
+static bool eliza_is_region(const char * region_name) {
+    return region_name &&
+        (std::strcmp(region_name, "tts") == 0 ||
+         std::strcmp(region_name, "asr") == 0 ||
+         std::strcmp(region_name, "text") == 0 ||
+         std::strcmp(region_name, "mtp") == 0 ||
+         std::strcmp(region_name, "vad") == 0);
+}
+
+static std::vector<std::string> eliza_find_ggufs(const std::filesystem::path & dir) {
+    std::vector<std::string> out;
+    std::error_code ec;
+    if (!std::filesystem::exists(dir, ec) || !std::filesystem::is_directory(dir, ec)) return out;
+    for (const auto & entry : std::filesystem::recursive_directory_iterator(dir, ec)) {
+        if (ec) break;
+        if (!entry.is_regular_file(ec)) continue;
+        const auto path = entry.path();
+        if (path.extension() == ".gguf") out.push_back(path.string());
+    }
+    std::sort(out.begin(), out.end());
+    return out;
+}
+
+static std::string eliza_lower_ascii(std::string value) {
+    std::transform(value.begin(), value.end(), value.begin(), [](unsigned char c) {
+        return (char) std::tolower(c);
+    });
+    return value;
+}
+
+static bool eliza_pick_voice_files(
+    const std::filesystem::path & bundle_dir,
+    std::string & tts_model,
+    std::string & codec_model) {
+    std::vector<std::string> tts = eliza_find_ggufs(bundle_dir / "tts");
+    std::vector<std::string> codec = eliza_find_ggufs(bundle_dir / "codec");
+    if (tts.empty()) tts = eliza_find_ggufs(bundle_dir / "voice");
+    if (tts.empty()) return false;
+
+    std::vector<std::string> tts_candidates;
+    std::vector<std::string> codec_candidates = codec;
+    for (const std::string & path : tts) {
+        const std::string lower = eliza_lower_ascii(std::filesystem::path(path).filename().string());
+        const bool is_omnivoice = lower.find("omnivoice") != std::string::npos;
+        const bool is_codec = lower.find("tokenizer") != std::string::npos || lower.find("codec") != std::string::npos;
+        const bool is_other_voice = lower.find("kokoro") != std::string::npos;
+        if (is_omnivoice && !is_codec && !is_other_voice) {
+            tts_candidates.push_back(path);
+        }
+        if (is_omnivoice && is_codec) {
+            codec_candidates.push_back(path);
+        }
+    }
+
+    if (tts_candidates.empty() || codec_candidates.empty()) {
+        return false;
+    }
+
+    tts_model = tts_candidates[0];
+    codec_model = codec_candidates[0];
+    return true;
+}
+
+static bool eliza_pick_asr_files(
+    const std::filesystem::path & bundle_dir,
+    std::string & asr_model,
+    std::string & asr_mmproj) {
+    const auto asr_dir = bundle_dir / "asr";
+    std::error_code ec;
+    const auto canonical_model = asr_dir / "eliza-1-asr.gguf";
+    const auto canonical_mmproj = asr_dir / "eliza-1-asr-mmproj.gguf";
+    if (std::filesystem::is_regular_file(canonical_model, ec) &&
+        std::filesystem::is_regular_file(canonical_mmproj, ec)) {
+        asr_model = canonical_model.string();
+        asr_mmproj = canonical_mmproj.string();
+        return true;
+    }
+
+    std::vector<std::string> asr = eliza_find_ggufs(asr_dir);
+    std::vector<std::string> model_candidates;
+    std::vector<std::string> mmproj_candidates;
+    for (const auto & candidate : asr) {
+        const std::string filename = eliza_lower_ascii(std::filesystem::path(candidate).filename().string());
+        if (filename.find("mmproj") != std::string::npos) {
+            mmproj_candidates.push_back(candidate);
+        } else if (filename.find("tokenizer") == std::string::npos &&
+                   filename.find("support") == std::string::npos &&
+                   filename.find("vocab") == std::string::npos) {
+            model_candidates.push_back(candidate);
+        }
+    }
+    if (asr_model.empty() && model_candidates.size() == 1) {
+        asr_model = model_candidates[0];
+    }
+    if (asr_mmproj.empty() && mmproj_candidates.size() == 1) {
+        asr_mmproj = mmproj_candidates[0];
+    }
+    return !asr_model.empty() && !asr_mmproj.empty();
+}
+
+static std::once_flag eliza_llama_backend_once;
+
+static int eliza_thread_count(bool batch) {
+    unsigned int hw = std::thread::hardware_concurrency();
+    if (hw == 0) hw = 4;
+    const unsigned int cap = batch ? 8 : 4;
+    return (int) std::max(1u, std::min(hw, cap));
+}
+
+static void eliza_apply_tts_env_overrides(ov_tts_params * params) {
+    if (!params) return;
+    if (const char * env = std::getenv("ELIZA_TTS_MASKGIT_STEPS")) {
+        int n = std::atoi(env);
+        if (n >= 1 && n <= 64) {
+            params->mg_num_step = n;
+        }
+    }
+    if (const char * env = std::getenv("ELIZA_TTS_CHUNK_DURATION_SEC")) {
+        char * end = nullptr;
+        float v = std::strtof(env, &end);
+        if (end != env && v > 0.0f && v <= 120.0f) {
+            params->chunk_duration_sec = v;
+        }
+    }
+    if (const char * env = std::getenv("ELIZA_TTS_CHUNK_THRESHOLD_SEC")) {
+        char * end = nullptr;
+        float v = std::strtof(env, &end);
+        if (end != env && v > 0.0f && v <= 120.0f) {
+            params->chunk_threshold_sec = v;
+        }
+    }
+}
+
+/* ASR thread budget. The voice-realtime caps in eliza_thread_count() exist
+ * so TTS + the MTP drafter keep cores free during a streaming turn; the
+ * ASR Whisper-style audio encoder (the mmproj prefill via
+ * mtmd_helper_eval_chunks) and the short greedy text decode are *not*
+ * barge-in-sensitive — they run once per utterance, before TTS competes —
+ * so they can use more cores. Scale the encoder up to half the box (it is
+ * the dominant cost on a ~30 s window) and keep the decode moderate. The
+ * ELIZA_ASR_THREADS env var overrides both when set. */
+static int eliza_asr_thread_count(bool encoder) {
+    if (const char * env = std::getenv("ELIZA_ASR_THREADS")) {
+        int n = std::atoi(env);
+        if (n > 0) return n;
+    }
+    unsigned int hw = std::thread::hardware_concurrency();
+    if (hw == 0) hw = 4;
+    const unsigned int cap = encoder ? std::max(8u, hw / 2u) : std::max(4u, hw / 4u);
+    return (int) std::max(1u, std::min(hw, cap));
+}
+
+static std::vector<float> eliza_resample_linear(
+    const float * pcm,
+    size_t n_samples,
+    int source_rate,
+    int target_rate) {
+    if (source_rate == target_rate || n_samples <= 1) {
+        return std::vector<float>(pcm, pcm + n_samples);
+    }
+    const double scale = (double) target_rate / (double) source_rate;
+    const size_t out_samples = std::max<size_t>(1, (size_t) std::llround((double) n_samples * scale));
+    std::vector<float> out(out_samples);
+    for (size_t i = 0; i < out_samples; ++i) {
+        const double src = (double) i * (double) source_rate / (double) target_rate;
+        const size_t lo = std::min((size_t) std::floor(src), n_samples - 1);
+        const size_t hi = std::min(lo + 1, n_samples - 1);
+        const float t = (float) (src - (double) lo);
+        out[i] = pcm[lo] * (1.0f - t) + pcm[hi] * t;
+    }
+    return out;
+}
+
+static std::string eliza_llama_token_piece(const llama_vocab * vocab, llama_token token) {
+    char small[256];
+    int32_t n = llama_token_to_piece(vocab, token, small, (int32_t) sizeof(small), 0, false);
+    if (n > 0) return std::string(small, (size_t) n);
+    if (n == 0) return "";
+    std::string buf((size_t) -n, '\\0');
+    n = llama_token_to_piece(vocab, token, buf.data(), (int32_t) buf.size(), 0, false);
+    if (n > 0) return std::string(buf.data(), (size_t) n);
+    return "";
+}
+
+static std::string eliza_trim_ascii(std::string value);
+
+static std::string eliza_asr_force_language() {
+    const char * env = std::getenv("ELIZA_ASR_FORCE_LANGUAGE");
+    if (!env) return "English";
+    std::string value = eliza_trim_ascii(env);
+    std::string lower = value;
+    std::transform(lower.begin(), lower.end(), lower.begin(), [](unsigned char c) {
+        return (char) std::tolower(c);
+    });
+    if (lower.empty() || lower == "0" || lower == "false" || lower == "none" || lower == "auto") {
+        return "";
+    }
+    return value;
+}
+
+static std::string eliza_format_asr_prompt(llama_model * model) {
+    (void) model;
+    // Match llama-mtmd-cli's Qwen3-ASR path: one user turn with audio first,
+    // a plain transcription instruction, then the assistant generation prompt.
+    // Forcing "language X<asr_text>" before decode makes the 0.6B ASR emit EOG
+    // too early on short mobile-loopback clips.
+    std::string prompt = std::string("<|im_start|>user\\n") +
+        mtmd_default_marker() +
+        "Transcribe audio to text";
+    std::string language = eliza_asr_force_language();
+    if (!language.empty()) {
+        prompt += " in " + language;
+    }
+    prompt += "<|im_end|>\\n<|im_start|>assistant\\n";
+    return prompt;
+}
+
+static std::string eliza_trim_ascii(std::string value) {
+    auto is_space = [](unsigned char c) {
+        return c == ' ' || c == '\\n' || c == '\\r' || c == '\\t';
+    };
+    while (!value.empty() && is_space((unsigned char) value.front())) {
+        value.erase(value.begin());
+    }
+    while (!value.empty() && is_space((unsigned char) value.back())) {
+        value.pop_back();
+    }
+    return value;
+}
+
+static std::string eliza_clean_asr_transcript(std::string transcript) {
+    const std::string asr_marker = "<asr_text>";
+    size_t marker = transcript.find(asr_marker);
+    if (marker != std::string::npos) {
+        transcript = transcript.substr(marker + asr_marker.size());
+    }
+    const char * sentinels[] = {
+        "<|im_start|>",
+        "<|im_end|>",
+        "<|endoftext|>",
+        "<|audio_start|>",
+        "<|audio_end|>",
+        "<|vision_start|>",
+        "<|vision_end|>",
+        "</s>",
+    };
+    for (const char * sentinel : sentinels) {
+        size_t pos = transcript.find(sentinel);
+        if (pos != std::string::npos) {
+            transcript = transcript.substr(0, pos);
+        }
+    }
+    transcript = eliza_trim_ascii(transcript);
+    for (const char * sentinel : sentinels) {
+        std::string full(sentinel);
+        if (full.rfind(transcript, 0) == 0) {
+            return "";
+        }
+    }
+    return transcript;
+}
+
+static bool eliza_asr_has_text_payload(const std::string & transcript) {
+    for (unsigned char c : transcript) {
+        if (std::isalnum(c)) return true;
+    }
+    return false;
+}
+
+static int eliza_map_ov_status(ov_status rc) {
+    if (rc == OV_STATUS_OK) return ELIZA_OK;
+    if (rc == OV_STATUS_OOM) return ELIZA_ERR_OOM;
+    if (rc == OV_STATUS_CANCELLED) return ELIZA_ERR_CANCELLED;
+    if (rc == OV_STATUS_INVALID_PARAMS || rc == OV_STATUS_INSTRUCT_INVALID) return ELIZA_ERR_INVALID_ARG;
+    return ELIZA_ERR_FFI_FAULT;
+}
+
+static bool eliza_tts_cancel_requested(void * user_data) {
+    EliInferenceContext * ctx = (EliInferenceContext *) user_data;
+    return ctx && ctx->tts_cancel.load(std::memory_order_acquire);
+}
+
+struct ElizaScopedTtsForward {
+    EliInferenceContext * ctx;
+
+    explicit ElizaScopedTtsForward(EliInferenceContext * c) : ctx(c) {
+        if (ctx) ctx->tts_cancel.store(false, std::memory_order_release);
+    }
+
+    ~ElizaScopedTtsForward() {
+        if (ctx) ctx->tts_cancel.store(false, std::memory_order_release);
+    }
+};
+
+struct ElizaTtsStreamState {
+    EliInferenceContext * ctx;
+    eliza_tts_chunk_cb on_chunk;
+    void * user_data;
+    bool callback_cancelled;
+};
+
+static bool eliza_tts_stream_chunk(const float * samples, int n_samples, void * user_data) {
+    ElizaTtsStreamState * state = (ElizaTtsStreamState *) user_data;
+    if (!state || !state->on_chunk) return false;
+    if (state->ctx && state->ctx->tts_cancel.load(std::memory_order_acquire)) return false;
+    const int rc = state->on_chunk(samples, n_samples < 0 ? 0 : (size_t) n_samples, 0, state->user_data);
+    if (rc != 0) {
+        state->callback_cancelled = true;
+        if (state->ctx) state->ctx->tts_cancel.store(true, std::memory_order_release);
+        return false;
+    }
+    return !(state->ctx && state->ctx->tts_cancel.load(std::memory_order_acquire));
+}
+
+static void eliza_free_asr(EliInferenceContext * ctx) {
+    if (!ctx) return;
+    if (ctx->asr_sampler) {
+        llama_sampler_free(ctx->asr_sampler);
+        ctx->asr_sampler = nullptr;
+    }
+    if (ctx->asr_mtmd) {
+        mtmd_free(ctx->asr_mtmd);
+        ctx->asr_mtmd = nullptr;
+    }
+    if (ctx->asr_lctx) {
+        llama_free(ctx->asr_lctx);
+        ctx->asr_lctx = nullptr;
+    }
+    if (ctx->asr_model) {
+        llama_model_free(ctx->asr_model);
+        ctx->asr_model = nullptr;
+    }
+    ctx->asr_sample_rate = 0;
+}
+
+static int eliza_load_tts(EliInferenceContext * ctx, char ** out_error) {
+    if (!ctx) {
+        eliza_set_error(out_error, "[libelizainference] load_tts: ctx is NULL");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+    std::lock_guard<std::mutex> lock(ctx->tts_mutex);
+    if (ctx->ov) return ELIZA_OK;
+    if (ctx->tts_model_path.empty()) {
+        if (!eliza_pick_voice_files(std::filesystem::path(ctx->bundle_dir), ctx->tts_model_path, ctx->codec_model_path)) {
+            eliza_set_error(out_error, std::string("[libelizainference] no TTS GGUF found under ") + (std::filesystem::path(ctx->bundle_dir) / "tts").string());
+            return ELIZA_ERR_BUNDLE_INVALID;
+        }
+    }
+
+    ov_init_params params;
+    ov_init_default_params(&params);
+    params.model_path = ctx->tts_model_path.c_str();
+    params.codec_path = ctx->codec_model_path.c_str();
+    params.use_fa = true;
+    ctx->ov = ov_init(&params);
+    if (!ctx->ov) {
+        std::string msg = "[libelizainference] ov_init failed: ";
+        msg += ov_last_error();
+        msg += " tts_model=";
+        msg += ctx->tts_model_path;
+        msg += " codec_model=";
+        msg += ctx->codec_model_path;
+        eliza_set_error(out_error, msg);
+        return ELIZA_ERR_FFI_FAULT;
+    }
+    return ELIZA_OK;
+}
+
+static int eliza_load_asr(EliInferenceContext * ctx, char ** out_error) {
+    if (!ctx) {
+        eliza_set_error(out_error, "[libelizainference] load_asr: ctx is NULL");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+    std::lock_guard<std::mutex> lock(ctx->asr_mutex);
+    if (ctx->asr_model && ctx->asr_lctx && ctx->asr_mtmd && ctx->asr_sampler) {
+        return ELIZA_OK;
+    }
+    if (ctx->asr_model_path.empty() || ctx->asr_mmproj_path.empty()) {
+        if (!eliza_pick_asr_files(std::filesystem::path(ctx->bundle_dir), ctx->asr_model_path, ctx->asr_mmproj_path)) {
+            eliza_set_error(out_error, std::string("[libelizainference] ASR requires both a text GGUF and mmproj GGUF under ") + (std::filesystem::path(ctx->bundle_dir) / "asr").string());
+            return ELIZA_ERR_BUNDLE_INVALID;
+        }
+    }
+
+    std::call_once(eliza_llama_backend_once, []() {
+        llama_backend_init();
+    });
+
+    llama_model_params mparams = llama_model_default_params();
+    mparams.n_gpu_layers = 99;
+    mparams.use_mmap = true;
+    ctx->asr_model = llama_model_load_from_file(ctx->asr_model_path.c_str(), mparams);
+    if (!ctx->asr_model) {
+        eliza_free_asr(ctx);
+        eliza_set_error(out_error, std::string("[libelizainference] failed to load ASR model: ") + ctx->asr_model_path);
+        return ELIZA_ERR_BUNDLE_INVALID;
+    }
+
+    llama_context_params cparams = llama_context_default_params();
+    cparams.n_ctx = 8192;
+    cparams.n_batch = (uint32_t) ctx->asr_n_batch;
+    cparams.n_ubatch = (uint32_t) ctx->asr_n_batch;
+    cparams.n_threads = eliza_asr_thread_count(false);
+    cparams.n_threads_batch = eliza_asr_thread_count(true);
+    cparams.flash_attn_type = LLAMA_FLASH_ATTN_TYPE_AUTO;
+    ctx->asr_lctx = llama_init_from_model(ctx->asr_model, cparams);
+    if (!ctx->asr_lctx) {
+        eliza_free_asr(ctx);
+        eliza_set_error(out_error, "[libelizainference] failed to initialize ASR llama context");
+        return ELIZA_ERR_FFI_FAULT;
+    }
+
+    mtmd_context_params aparams = mtmd_context_params_default();
+    aparams.use_gpu = true;
+    aparams.print_timings = false;
+    aparams.n_threads = eliza_asr_thread_count(true);
+    aparams.flash_attn_type = LLAMA_FLASH_ATTN_TYPE_AUTO;
+    aparams.warmup = true;
+    ctx->asr_mtmd = mtmd_init_from_file(ctx->asr_mmproj_path.c_str(), ctx->asr_model, aparams);
+    if (!ctx->asr_mtmd) {
+        eliza_free_asr(ctx);
+        eliza_set_error(out_error, std::string("[libelizainference] failed to load ASR mmproj: ") + ctx->asr_mmproj_path);
+        return ELIZA_ERR_BUNDLE_INVALID;
+    }
+    if (!mtmd_support_audio(ctx->asr_mtmd)) {
+        eliza_free_asr(ctx);
+        eliza_set_error(out_error, "[libelizainference] ASR mmproj does not report audio support");
+        return ELIZA_ERR_BUNDLE_INVALID;
+    }
+    ctx->asr_sample_rate = mtmd_get_audio_sample_rate(ctx->asr_mtmd);
+    if (ctx->asr_sample_rate <= 0) {
+        eliza_free_asr(ctx);
+        eliza_set_error(out_error, "[libelizainference] ASR mmproj returned an invalid audio sample rate");
+        return ELIZA_ERR_BUNDLE_INVALID;
+    }
+
+    llama_sampler_chain_params sparams = llama_sampler_chain_default_params();
+    ctx->asr_sampler = llama_sampler_chain_init(sparams);
+    if (!ctx->asr_sampler) {
+        eliza_free_asr(ctx);
+        eliza_set_error(out_error, "[libelizainference] failed to initialize ASR sampler");
+        return ELIZA_ERR_FFI_FAULT;
+    }
+    llama_sampler_chain_add(ctx->asr_sampler, llama_sampler_init_greedy());
+    return ELIZA_OK;
+}
+
+/* ---- Streaming LLM (text generation) ------------------------------- *
+ * Deprecated-graft mirror of the in-tree
+ * tools/omnivoice/src/eliza-inference-ffi.cpp implementation. See the ABI
+ * in tools/omnivoice/include/eliza-inference-ffi.h. */
+
+static int eliza_llm_int_env_or_default(const char * name, int fallback) {
+    if (const char * env = std::getenv(name)) {
+        int n = std::atoi(env);
+        if (n > 0) return n;
+    }
+    return fallback;
+}
+
+static bool eliza_llm_bool_env_or_default(const char * name, bool fallback) {
+    if (const char * env = std::getenv(name)) {
+        std::string value = env;
+        std::transform(value.begin(), value.end(), value.begin(), [](unsigned char c) {
+            return (char) std::tolower(c);
+        });
+        if (value == "1" || value == "true" || value == "yes" || value == "on") return true;
+        if (value == "0" || value == "false" || value == "no" || value == "off") return false;
+    }
+    return fallback;
+}
+
+struct EliLlmStream {
+    EliInferenceContext * ctx = nullptr;
+    llama_context * lctx = nullptr;
+    llama_sampler * sampler = nullptr;
+    int n_past = 0;
+    int generated = 0;
+    int max_tokens = 0;
+    bool eos = false;
+    std::atomic<bool> cancel{false};
+};
+
+static bool eliza_pick_text_file(
+    const std::filesystem::path & bundle_dir,
+    std::string & text_model) {
+    std::vector<std::string> candidates = eliza_find_ggufs(bundle_dir / "text");
+    std::vector<std::string> picked;
+    for (const std::string & path : candidates) {
+        const std::string lower =
+            eliza_lower_ascii(std::filesystem::path(path).filename().string());
+        if (lower.find("mmproj") != std::string::npos) continue;
+        if (lower.find("tokenizer") != std::string::npos) continue;
+        if (lower.find("codec") != std::string::npos) continue;
+        picked.push_back(path);
+    }
+    if (picked.empty()) return false;
+    text_model = picked[0];
+    return true;
+}
+
+static int eliza_load_llm_model_locked(
+    EliInferenceContext * ctx,
+    char ** out_error) {
+    if (ctx->llm_model) return ELIZA_OK;
+    if (ctx->llm_model_path.empty()) {
+        if (!eliza_pick_text_file(std::filesystem::path(ctx->bundle_dir),
+                                  ctx->llm_model_path)) {
+            eliza_set_error(out_error,
+                std::string("[libelizainference] no text GGUF found under ") +
+                (std::filesystem::path(ctx->bundle_dir) / "text").string());
+            return ELIZA_ERR_BUNDLE_INVALID;
+        }
+    }
+    std::call_once(eliza_llama_backend_once, []() { llama_backend_init(); });
+    llama_model_params mparams = llama_model_default_params();
+    mparams.n_gpu_layers = eliza_llm_bool_env_or_default("ELIZA_LLM_USE_GPU", true) ? 99 : 0;
+    mparams.use_mmap = true;
+    ctx->llm_model = llama_model_load_from_file(ctx->llm_model_path.c_str(), mparams);
+    if (!ctx->llm_model) {
+        eliza_set_error(out_error,
+            std::string("[libelizainference] failed to load text model: ") +
+            ctx->llm_model_path);
+        return ELIZA_ERR_BUNDLE_INVALID;
+    }
+    return ELIZA_OK;
+}
+
+static llama_sampler * eliza_build_llm_sampler_chain(
+    const llama_model * model,
+    const eliza_llm_stream_config_t * cfg,
+    char ** out_error) {
+    const llama_vocab * vocab = llama_model_get_vocab(model);
+    llama_sampler_chain_params sparams = llama_sampler_chain_default_params();
+    llama_sampler * chain = llama_sampler_chain_init(sparams);
+    if (!chain) {
+        eliza_set_error(out_error,
+            "[libelizainference] llm_stream: failed to init sampler chain");
+        return nullptr;
+    }
+    if (cfg->gbnf_grammar && cfg->gbnf_grammar[0] != '\\0') {
+        llama_sampler * grammar = llama_sampler_init_grammar(vocab, cfg->gbnf_grammar, "root");
+        if (!grammar) {
+            llama_sampler_free(chain);
+            eliza_set_error(out_error,
+                "[libelizainference] llm_stream: GBNF grammar failed to parse");
+            return nullptr;
+        }
+        llama_sampler_chain_add(chain, grammar);
+    }
+    if (cfg->repeat_penalty != 0.0f && cfg->repeat_penalty != 1.0f) {
+        llama_sampler_chain_add(chain,
+            llama_sampler_init_penalties(64, cfg->repeat_penalty, 0.0f, 0.0f));
+    }
+    const bool greedy = cfg->temperature <= 0.0f;
+    if (!greedy) {
+        if (cfg->top_k > 0) {
+            llama_sampler_chain_add(chain, llama_sampler_init_top_k(cfg->top_k));
+        }
+        if (cfg->top_p > 0.0f && cfg->top_p < 1.0f) {
+            llama_sampler_chain_add(chain, llama_sampler_init_top_p(cfg->top_p, 1));
+        }
+        llama_sampler_chain_add(chain, llama_sampler_init_temp(cfg->temperature));
+        llama_sampler_chain_add(chain, llama_sampler_init_dist(LLAMA_DEFAULT_SEED));
+    } else {
+        llama_sampler_chain_add(chain, llama_sampler_init_greedy());
+    }
+    return chain;
+}
+
+extern "C" {
+
+const char * eliza_inference_abi_version(void) {
+    // Keep this tied to ffi.h so ABI bumps cannot drift between the
+    // generated adapter and the TypeScript loader.
+    // Keep in lockstep with ELIZA_INFERENCE_ABI_VERSION in
+    // packages/app-core/src/services/local-inference/voice/ffi-bindings.ts.
+    return ELIZA_STRINGIFY(ELIZA_INFERENCE_ABI_VERSION);
+}
+
+EliInferenceContext * eliza_inference_create(
+    const char * bundle_dir,
+    char ** out_error) {
+    if (!bundle_dir || bundle_dir[0] == '\\0') {
+        eliza_set_error(out_error, "[libelizainference] bundle_dir is required");
+        return nullptr;
+    }
+    std::filesystem::path root(bundle_dir);
+    std::error_code ec;
+    if (!std::filesystem::exists(root, ec) || !std::filesystem::is_directory(root, ec)) {
+        eliza_set_error(out_error, std::string("[libelizainference] bundle_dir does not exist: ") + bundle_dir);
+        return nullptr;
+    }
+
+    EliInferenceContext * ctx = new (std::nothrow) EliInferenceContext();
+    if (!ctx) {
+        eliza_set_error(out_error, "[libelizainference] out of memory allocating context");
+        return nullptr;
+    }
+    ctx->bundle_dir = root.string();
+
+    // Metadata-only: heavy voice weights are intentionally loaded by
+    // eliza_inference_mmap_acquire("tts") so voice-off does not keep
+    // OmniVoice resident.
+    return ctx;
+}
+
+void eliza_inference_destroy(EliInferenceContext * ctx) {
+    if (!ctx) return;
+    {
+        std::lock_guard<std::mutex> lock(ctx->tts_mutex);
+        ov_free(ctx->ov);
+        ctx->ov = nullptr;
+    }
+    {
+        std::lock_guard<std::mutex> lock(ctx->asr_mutex);
+        eliza_free_asr(ctx);
+    }
+    {
+        std::lock_guard<std::mutex> lock(ctx->llm_mutex);
+        if (ctx->llm_model) {
+            llama_model_free(ctx->llm_model);
+            ctx->llm_model = nullptr;
+        }
+    }
+    delete ctx;
+}
+
+int eliza_inference_mmap_acquire(
+    EliInferenceContext * ctx,
+    const char * region_name,
+    char ** out_error) {
+    if (!ctx) {
+        eliza_set_error(out_error, "[libelizainference] mmap_acquire: ctx is NULL");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+    if (!eliza_is_region(region_name)) {
+        eliza_set_error(out_error, "[libelizainference] mmap_acquire: invalid region");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+    if (std::strcmp(region_name, "tts") == 0) {
+        return eliza_load_tts(ctx, out_error);
+    }
+    if (std::strcmp(region_name, "asr") == 0) {
+        return eliza_load_asr(ctx, out_error);
+    }
+    return ELIZA_OK;
+}
+
+int eliza_inference_mmap_evict(
+    EliInferenceContext * ctx,
+    const char * region_name,
+    char ** out_error) {
+    if (!ctx) {
+        eliza_set_error(out_error, "[libelizainference] mmap_evict: ctx is NULL");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+    if (!eliza_is_region(region_name)) {
+        eliza_set_error(out_error, "[libelizainference] mmap_evict: invalid region");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+    if (std::strcmp(region_name, "tts") == 0) {
+        std::lock_guard<std::mutex> lock(ctx->tts_mutex);
+        if (ctx->ov) {
+            ov_free(ctx->ov);
+            ctx->ov = nullptr;
+        }
+    }
+    if (std::strcmp(region_name, "asr") == 0) {
+        std::lock_guard<std::mutex> lock(ctx->asr_mutex);
+        eliza_free_asr(ctx);
+    }
+    return ELIZA_OK;
+}
+
+int eliza_inference_tts_synthesize(
+    EliInferenceContext * ctx,
+    const char * text,
+    size_t text_len,
+    const char * speaker_preset_id,
+    float * out_pcm,
+    size_t max_samples,
+    char ** out_error) {
+    if (!ctx || !out_pcm || max_samples == 0) {
+        eliza_set_error(out_error, "[libelizainference] tts_synthesize: invalid arguments");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+    if (!text || text_len == 0) {
+        eliza_set_error(out_error, "[libelizainference] tts_synthesize: text is required");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+
+    std::lock_guard<std::mutex> lock(ctx->tts_mutex);
+    if (!ctx->ov) {
+        eliza_set_error(out_error, "[libelizainference] tts_synthesize: TTS region is not acquired; call mmap_acquire(\\"tts\\") after arming voice");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+    ElizaScopedTtsForward forward(ctx);
+
+    std::string text_owned(text, text_len);
+    ov_tts_params params;
+    ov_tts_default_params(&params);
+    eliza_apply_tts_env_overrides(&params);
+    params.text = text_owned.c_str();
+    /* Default to OmniVoice's auto-voice path. The preset (if any)
+     * overwrites params.instruct / ref_audio_tokens / ref_text via
+     * eliza_apply_preset_to_params below. */
+    params.instruct = "";
+    if (speaker_preset_id && speaker_preset_id[0] != '\\0') {
+        std::string preset_err;
+        const EliVoicePreset * preset = nullptr;
+        {
+            std::lock_guard<std::mutex> preset_lock(ctx->preset_mutex);
+            preset = eliza_load_voice_preset_locked(ctx, speaker_preset_id, preset_err);
+        }
+        if (preset && !preset->empty_payload) {
+            eliza_apply_preset_to_params(*preset, &params);
+        }
+        /* A missing or v1-only preset is not fatal — auto-voice mode
+         * still produces audio. The preset_err is only surfaced via
+         * out_error when synthesis itself fails. */
+    }
+    params.cancel = eliza_tts_cancel_requested;
+    params.cancel_user_data = ctx;
+
+    ov_audio audio = {};
+    ov_status rc = ov_synthesize(ctx->ov, &params, &audio);
+    if (rc != OV_STATUS_OK) {
+        std::string msg = "[libelizainference] ov_synthesize failed: ";
+        msg += ov_last_error();
+        ov_audio_free(&audio);
+        eliza_set_error(out_error, msg);
+        return eliza_map_ov_status(rc);
+    }
+    if (audio.n_samples < 0 || (size_t) audio.n_samples > max_samples) {
+        std::string msg = "[libelizainference] output buffer too small; required samples=" +
+            std::to_string(audio.n_samples);
+        ov_audio_free(&audio);
+        eliza_set_error(out_error, msg);
+        return ELIZA_ERR_INVALID_ARG;
+    }
+    std::memcpy(out_pcm, audio.samples, (size_t) audio.n_samples * sizeof(float));
+    int written = audio.n_samples;
+    ov_audio_free(&audio);
+    return written;
+}
+
+int eliza_inference_asr_transcribe(
+    EliInferenceContext * ctx,
+    const float * pcm,
+    size_t n_samples,
+    int sample_rate_hz,
+    char * out_text,
+    size_t max_text_bytes,
+    char ** out_error) {
+    if (!ctx || !pcm || !out_text || max_text_bytes == 0 || sample_rate_hz <= 0) {
+        eliza_set_error(out_error, "[libelizainference] asr_transcribe: invalid arguments");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+    if (n_samples == 0) {
+        out_text[0] = '\\0';
+        return 0;
+    }
+
+    std::lock_guard<std::mutex> lock(ctx->asr_mutex);
+    if (!ctx->asr_model || !ctx->asr_lctx || !ctx->asr_mtmd || !ctx->asr_sampler) {
+        eliza_set_error(out_error, "[libelizainference] asr_transcribe: ASR region is not acquired; call mmap_acquire(\\"asr\\") after arming voice input");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+
+    std::vector<float> audio = eliza_resample_linear(pcm, n_samples, sample_rate_hz, ctx->asr_sample_rate);
+    std::unique_ptr<mtmd_bitmap, decltype(&mtmd_bitmap_free)> bitmap(
+        mtmd_bitmap_init_from_audio(audio.size(), audio.data()),
+        mtmd_bitmap_free);
+    if (!bitmap) {
+        eliza_set_error(out_error, "[libelizainference] asr_transcribe: failed to create audio bitmap");
+        return ELIZA_ERR_FFI_FAULT;
+    }
+
+    std::string prompt = eliza_format_asr_prompt(ctx->asr_model);
+    mtmd_input_text text = { prompt.c_str(), true, true };
+    const mtmd_bitmap * bitmaps[] = { bitmap.get() };
+    std::unique_ptr<mtmd_input_chunks, decltype(&mtmd_input_chunks_free)> chunks(
+        mtmd_input_chunks_init(),
+        mtmd_input_chunks_free);
+    if (!chunks) {
+        eliza_set_error(out_error, "[libelizainference] asr_transcribe: failed to allocate input chunks");
+        return ELIZA_ERR_FFI_FAULT;
+    }
+    int32_t tok_rc = mtmd_tokenize(ctx->asr_mtmd, chunks.get(), &text, bitmaps, 1);
+    if (tok_rc != 0) {
+        eliza_set_error(out_error, "[libelizainference] asr_transcribe: mtmd_tokenize failed rc=" + std::to_string(tok_rc));
+        return ELIZA_ERR_FFI_FAULT;
+    }
+
+    llama_memory_clear(llama_get_memory(ctx->asr_lctx), true);
+    llama_sampler_reset(ctx->asr_sampler);
+
+    llama_pos n_past = 0;
+    int32_t eval_rc = mtmd_helper_eval_chunks(
+        ctx->asr_mtmd,
+        ctx->asr_lctx,
+        chunks.get(),
+        n_past,
+        0,
+        ctx->asr_n_batch,
+        true,
+        &n_past);
+    if (eval_rc != 0) {
+        eliza_set_error(out_error, "[libelizainference] asr_transcribe: mtmd_helper_eval_chunks failed rc=" + std::to_string(eval_rc));
+        return ELIZA_ERR_FFI_FAULT;
+    }
+
+    const llama_vocab * vocab = llama_model_get_vocab(ctx->asr_model);
+    std::string transcript;
+    transcript.reserve(std::min<size_t>(max_text_bytes, 256));
+    const int max_decode_tokens = std::min<int>(
+        4096,
+        std::max<int>(
+            192,
+            64 + (int) (((audio.size() + (size_t) ctx->asr_sample_rate - 1) /
+                         (size_t) ctx->asr_sample_rate) * 32)));
+    bool completed = false;
+    for (int i = 0; i < max_decode_tokens; ++i) {
+        llama_token token = llama_sampler_sample(ctx->asr_sampler, ctx->asr_lctx, -1);
+        if (llama_vocab_is_eog(vocab, token)) {
+            completed = true;
+            break;
+        }
+        std::string piece = eliza_llama_token_piece(vocab, token);
+        if (!piece.empty()) {
+            if (transcript.size() + piece.size() + 1 > max_text_bytes) {
+                eliza_set_error(out_error, "[libelizainference] asr_transcribe: output buffer too small");
+                return ELIZA_ERR_INVALID_ARG;
+            }
+            transcript += piece;
+            std::string cleaned_partial = eliza_clean_asr_transcript(transcript);
+            if (eliza_asr_has_text_payload(cleaned_partial)) {
+                if (piece.find('\\n') != std::string::npos ||
+                    transcript.find("<|im_end|>") != std::string::npos ||
+                    transcript.find("<|endoftext|>") != std::string::npos ||
+                    transcript.find("</s>") != std::string::npos) {
+                    completed = true;
+                    break;
+                }
+            }
+        }
+        llama_sampler_accept(ctx->asr_sampler, token);
+        llama_batch batch = llama_batch_get_one(&token, 1);
+        int32_t decode_rc = llama_decode(ctx->asr_lctx, batch);
+        if (decode_rc != 0) {
+            eliza_set_error(out_error, "[libelizainference] asr_transcribe: llama_decode failed rc=" + std::to_string(decode_rc));
+            return ELIZA_ERR_FFI_FAULT;
+        }
+    }
+    if (!completed) {
+        eliza_set_error(out_error,
+            "[libelizainference] asr_transcribe: decode reached token cap before EOG; "
+            "refusing to return a possibly truncated transcript");
+        return ELIZA_ERR_FFI_FAULT;
+    } else {
+        transcript = eliza_clean_asr_transcript(transcript);
+    }
+
+    if (transcript.size() + 1 > max_text_bytes) {
+        eliza_set_error(out_error, "[libelizainference] asr_transcribe: output buffer too small after transcript normalization");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+    std::memcpy(out_text, transcript.data(), transcript.size());
+    out_text[transcript.size()] = '\\0';
+    return (int) transcript.size();
+}
+
+/* ---- Streaming ASR (ABI v2) ---------------------------------------- *
+ *
+ * The fused build ships the v1 batch \`eliza_inference_asr_transcribe\`
+ * decoder above; the windowed streaming-session decoder is not yet wired
+ * (W7). Per packages/inference/AGENTS.md §3 we do NOT fake it — the
+ * capability probe returns 0 so EngineVoiceBridge / StreamingTranscriber
+ * pick the fused batch ASR adapter instead of opening a session that would
+ * only return the unsupported-operation error code.
+ * These symbols exist so the ABI surface is complete and the loader's
+ * version check (ffi-bindings.ts expects v3) succeeds.
+ */
+
+int eliza_inference_asr_stream_supported(void) {
+    return 0;
+}
+
+EliAsrStream * eliza_inference_asr_stream_open(
+    EliInferenceContext * ctx,
+    int sample_rate_hz,
+    char ** out_error) {
+    (void) ctx;
+    (void) sample_rate_hz;
+    eliza_set_error(out_error,
+        "[libelizainference] streaming ASR session API is unsupported in this build "
+        "(eliza_inference_asr_stream_supported() == 0); use the batch transcribe path");
+    return nullptr;
+}
+
+int eliza_inference_asr_stream_feed(
+    EliAsrStream * stream,
+    const float * pcm,
+    size_t n_samples,
+    char ** out_error) {
+    (void) stream;
+    (void) pcm;
+    (void) n_samples;
+    eliza_set_error(out_error, "[libelizainference] streaming ASR is unsupported in this build");
+    return ELIZA_ERR_NOT_IMPLEMENTED;
+}
+
+int eliza_inference_asr_stream_partial(
+    EliAsrStream * stream,
+    char * out_text,
+    size_t max_text_bytes,
+    int * out_tokens,
+    size_t * io_n_tokens,
+    char ** out_error) {
+    (void) stream;
+    (void) out_text;
+    (void) max_text_bytes;
+    (void) out_tokens;
+    if (io_n_tokens) *io_n_tokens = 0;
+    eliza_set_error(out_error, "[libelizainference] streaming ASR is unsupported in this build");
+    return ELIZA_ERR_NOT_IMPLEMENTED;
+}
+
+int eliza_inference_asr_stream_finish(
+    EliAsrStream * stream,
+    char * out_text,
+    size_t max_text_bytes,
+    int * out_tokens,
+    size_t * io_n_tokens,
+    char ** out_error) {
+    (void) stream;
+    (void) out_text;
+    (void) max_text_bytes;
+    (void) out_tokens;
+    if (io_n_tokens) *io_n_tokens = 0;
+    eliza_set_error(out_error, "[libelizainference] streaming ASR is unsupported in this build");
+    return ELIZA_ERR_NOT_IMPLEMENTED;
+}
+
+void eliza_inference_asr_stream_close(EliAsrStream * stream) {
+    (void) stream;
+}
+
+/* ---- Streaming TTS + MTP verifier callback (ABI v2) ------------- *
+ *
+ * TTS streaming is backed by OmniVoice's real \`ov_tts_params.on_chunk\`
+ * path and cooperative cancel hook. The native MTP verifier-event
+ * callback is still not wired in this generated adapter, so the JS
+ * scheduler continues to synthesize verifier events from llama-server SSE
+ * deltas until that text-generation path moves in-process.
+ */
+
+int eliza_inference_tts_stream_supported(void) {
+    return OV_ABI_VERSION >= 2 ? 1 : 0;
+}
+
+int eliza_inference_tts_synthesize_stream(
+    EliInferenceContext * ctx,
+    const char * text,
+    size_t text_len,
+    const char * speaker_preset_id,
+    eliza_tts_chunk_cb on_chunk,
+    void * user_data,
+    char ** out_error) {
+    if (!ctx || !on_chunk) {
+        eliza_set_error(out_error, "[libelizainference] tts_synthesize_stream: invalid arguments");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+    if (!text || text_len == 0) {
+        eliza_set_error(out_error, "[libelizainference] tts_synthesize_stream: text is required");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+
+    std::lock_guard<std::mutex> lock(ctx->tts_mutex);
+    if (!ctx->ov) {
+        eliza_set_error(out_error, "[libelizainference] tts_synthesize_stream: TTS region is not acquired; call mmap_acquire(\\"tts\\") after arming voice");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+    ElizaScopedTtsForward forward(ctx);
+
+    std::string text_owned(text, text_len);
+    ov_tts_params params;
+    ov_tts_default_params(&params);
+    eliza_apply_tts_env_overrides(&params);
+    params.text = text_owned.c_str();
+    /* Default to OmniVoice's auto-voice path. The preset (if any)
+     * overwrites params.instruct / ref_audio_tokens / ref_text via
+     * eliza_apply_preset_to_params below. */
+    params.instruct = "";
+    if (speaker_preset_id && speaker_preset_id[0] != '\\0') {
+        std::string preset_err;
+        const EliVoicePreset * preset = nullptr;
+        {
+            std::lock_guard<std::mutex> preset_lock(ctx->preset_mutex);
+            preset = eliza_load_voice_preset_locked(ctx, speaker_preset_id, preset_err);
+        }
+        if (preset && !preset->empty_payload) {
+            eliza_apply_preset_to_params(*preset, &params);
+        }
+        /* A missing or v1-only preset is not fatal — auto-voice mode
+         * still produces audio. The preset_err is only surfaced via
+         * out_error when synthesis itself fails. */
+    }
+    params.cancel = eliza_tts_cancel_requested;
+    params.cancel_user_data = ctx;
+
+    ElizaTtsStreamState state = {
+        ctx,
+        on_chunk,
+        user_data,
+        false,
+    };
+    params.on_chunk = eliza_tts_stream_chunk;
+    params.on_chunk_user_data = &state;
+
+    ov_status rc = ov_synthesize(ctx->ov, &params, nullptr);
+    const bool cancelled =
+        rc == OV_STATUS_CANCELLED ||
+        state.callback_cancelled ||
+        ctx->tts_cancel.load(std::memory_order_acquire);
+    (void) on_chunk(nullptr, 0, 1, user_data);
+    if (cancelled) {
+        return ELIZA_ERR_CANCELLED;
+    }
+    if (rc != OV_STATUS_OK) {
+        std::string msg = "[libelizainference] ov_synthesize(stream) failed: ";
+        msg += ov_last_error();
+        eliza_set_error(out_error, msg);
+        return eliza_map_ov_status(rc);
+    }
+    return ELIZA_OK;
+}
+
+int eliza_inference_cancel_tts(
+    EliInferenceContext * ctx,
+    char ** out_error) {
+    (void) out_error;
+    if (ctx) {
+        ctx->tts_cancel.store(true, std::memory_order_release);
+    }
+    // Cancelling nothing is not an error.
+    return ELIZA_OK;
+}
+
+int eliza_inference_set_verifier_callback(
+    EliInferenceContext * ctx,
+    eliza_verifier_cb cb,
+    void * user_data,
+    char ** out_error) {
+    (void) ctx;
+    (void) cb;
+    (void) user_data;
+    eliza_set_error(out_error,
+        "[libelizainference] native MTP verifier callback is unsupported in this build; "
+        "the JS scheduler synthesizes verifier events from llama-server streaming deltas");
+    return ELIZA_ERR_NOT_IMPLEMENTED;
+}
+
+/* ---- OmniVoice reference encode (ABI v4) -------------------------- *
+ *
+ * Thin wrapper around ov_encode_reference. The TTS region must have
+ * been acquired (\`mmap_acquire("tts")\`) before the call. The library
+ * malloc-allocates the token buffer; callers release it via
+ * eliza_inference_free_tokens.
+ */
+int eliza_inference_encode_reference(
+    EliInferenceContext * ctx,
+    const float * pcm,
+    size_t n_samples,
+    int sample_rate_hz,
+    int * out_K,
+    int * out_ref_T,
+    int ** out_tokens,
+    char ** out_error) {
+    if (!ctx || !pcm || !out_K || !out_ref_T || !out_tokens) {
+        eliza_set_error(out_error, "[libelizainference] encode_reference: invalid arguments");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+    if (n_samples == 0) {
+        eliza_set_error(out_error, "[libelizainference] encode_reference: n_samples must be > 0");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+    if (sample_rate_hz != 24000) {
+        eliza_set_error(out_error,
+            "[libelizainference] encode_reference: sample_rate_hz must be 24000 (got " +
+            std::to_string(sample_rate_hz) + "); caller is responsible for upstream resample");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+
+    std::lock_guard<std::mutex> lock(ctx->tts_mutex);
+    if (!ctx->ov) {
+        eliza_set_error(out_error,
+            "[libelizainference] encode_reference: TTS region is not acquired; "
+            "call mmap_acquire(\\"tts\\") after arming voice");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+
+    int32_t * tokens = nullptr;
+    int K = 0;
+    int ref_T = 0;
+    ov_status rc = ov_encode_reference(ctx->ov, pcm, (int) n_samples,
+                                       &tokens, &K, &ref_T);
+    if (rc != OV_STATUS_OK) {
+        std::string msg = "[libelizainference] ov_encode_reference failed: ";
+        msg += ov_last_error();
+        eliza_set_error(out_error, msg);
+        if (tokens) std::free(tokens);
+        return eliza_map_ov_status(rc);
+    }
+    *out_tokens = tokens;
+    *out_K = K;
+    *out_ref_T = ref_T;
+    return ELIZA_OK;
+}
+
+void eliza_inference_free_tokens(int * tokens) {
+    if (tokens) std::free(tokens);
+}
+
+/* ---- Native VAD (ABI v3) ------------------------------------------- *
+ *
+ * The JS runtime can use the ONNX Silero path today. Native VAD is an
+ * additive fused-runtime backend; until the fused target wires it,
+ * advertise unsupported and return structured unsupported-operation errors.
+ */
+
+int eliza_inference_vad_supported(void) {
+    return 0;
+}
+
+EliVad * eliza_inference_vad_open(
+    EliInferenceContext * ctx,
+    int sample_rate_hz,
+    char ** out_error) {
+    (void) ctx;
+    (void) sample_rate_hz;
+    eliza_set_error(out_error,
+        "[libelizainference] native VAD is unsupported in this build "
+        "(eliza_inference_vad_supported() == 0); use the ONNX Silero VAD path");
+    return nullptr;
+}
+
+int eliza_inference_vad_process(
+    EliVad * vad,
+    const float * pcm,
+    size_t n_samples,
+    float * out_probability,
+    char ** out_error) {
+    (void) vad;
+    (void) pcm;
+    (void) n_samples;
+    (void) out_probability;
+    eliza_set_error(out_error, "[libelizainference] native VAD is unsupported in this build");
+    return ELIZA_ERR_NOT_IMPLEMENTED;
+}
+
+int eliza_inference_vad_reset(
+    EliVad * vad,
+    char ** out_error) {
+    (void) vad;
+    eliza_set_error(out_error, "[libelizainference] native VAD is unsupported in this build");
+    return ELIZA_ERR_NOT_IMPLEMENTED;
+}
+
+void eliza_inference_vad_close(EliVad * vad) {
+    (void) vad;
+}
+
+/* ---- Streaming LLM (text generation, ABI v4) --------------------- */
+
+int eliza_inference_llm_stream_supported(void) {
+    return 1;
+}
+
+EliLlmStream * eliza_inference_llm_stream_open(
+    EliInferenceContext * ctx,
+    const eliza_llm_stream_config_t * cfg,
+    char ** out_error) {
+    if (!ctx || !cfg) {
+        eliza_set_error(out_error,
+            "[libelizainference] llm_stream_open: ctx and cfg are required");
+        return nullptr;
+    }
+    llama_model * model = nullptr;
+    {
+        std::lock_guard<std::mutex> lock(ctx->llm_mutex);
+        int rc = eliza_load_llm_model_locked(ctx, out_error);
+        if (rc != ELIZA_OK) return nullptr;
+        model = ctx->llm_model;
+    }
+    EliLlmStream * stream = new (std::nothrow) EliLlmStream();
+    if (!stream) {
+        eliza_set_error(out_error, "[libelizainference] llm_stream_open: out of memory");
+        return nullptr;
+    }
+    stream->ctx = ctx;
+    stream->max_tokens = cfg->max_tokens > 0 ? cfg->max_tokens : 0;
+    llama_context_params cparams = llama_context_default_params();
+    const int n_ctx_train = llama_model_n_ctx_train(model);
+    int n_ctx = eliza_llm_int_env_or_default("ELIZA_LLM_N_CTX", 8192);
+    if (n_ctx_train > 0 && n_ctx > n_ctx_train) n_ctx = n_ctx_train;
+    cparams.n_ctx = (uint32_t) n_ctx;
+    cparams.n_batch = (uint32_t) eliza_llm_int_env_or_default("ELIZA_LLM_N_BATCH", 512);
+    cparams.n_ubatch = cparams.n_batch;
+    cparams.n_threads = eliza_thread_count(false);
+    cparams.n_threads_batch = eliza_thread_count(true);
+    cparams.flash_attn_type = LLAMA_FLASH_ATTN_TYPE_AUTO;
+    stream->lctx = llama_init_from_model(model, cparams);
+    if (!stream->lctx) {
+        delete stream;
+        eliza_set_error(out_error,
+            "[libelizainference] llm_stream_open: failed to init llama context");
+        return nullptr;
+    }
+    stream->sampler = eliza_build_llm_sampler_chain(model, cfg, out_error);
+    if (!stream->sampler) {
+        llama_free(stream->lctx);
+        delete stream;
+        return nullptr;
+    }
+    return stream;
+}
+
+int eliza_inference_llm_stream_prefill(
+    EliLlmStream * stream,
+    const int32_t * token_ids,
+    size_t num_tokens,
+    char ** out_error) {
+    if (!stream || !stream->lctx) {
+        eliza_set_error(out_error, "[libelizainference] llm_stream_prefill: invalid session");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+    if (num_tokens == 0) return ELIZA_OK;
+    if (!token_ids) {
+        eliza_set_error(out_error, "[libelizainference] llm_stream_prefill: token_ids is NULL");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+    std::vector<llama_token> tokens(token_ids, token_ids + num_tokens);
+    const int n_batch = (int) llama_n_batch(stream->lctx);
+    const size_t total = tokens.size();
+    for (size_t off = 0; off < total; off += (size_t) n_batch) {
+        if (stream->cancel.load(std::memory_order_acquire)) {
+            eliza_set_error(out_error, "[libelizainference] llm_stream_prefill: cancelled");
+            return ELIZA_ERR_CANCELLED;
+        }
+        const size_t chunk = std::min((size_t) n_batch, total - off);
+        llama_batch batch = llama_batch_get_one(tokens.data() + off, (int32_t) chunk);
+        int32_t rc = llama_decode(stream->lctx, batch);
+        if (rc != 0) {
+            eliza_set_error(out_error,
+                "[libelizainference] llm_stream_prefill: llama_decode failed rc=" +
+                std::to_string(rc));
+            return ELIZA_ERR_FFI_FAULT;
+        }
+        stream->n_past += (int) chunk;
+    }
+    return ELIZA_OK;
+}
+
+int eliza_inference_llm_stream_next(
+    EliLlmStream * stream,
+    int32_t * tokens_out,
+    size_t tokens_cap,
+    size_t * num_tokens_out,
+    char * text_out,
+    size_t text_cap,
+    int32_t * drafter_drafted_out,
+    int32_t * drafter_accepted_out,
+    char ** out_error) {
+    if (num_tokens_out) *num_tokens_out = 0;
+    if (drafter_drafted_out) *drafter_drafted_out = 0;
+    if (drafter_accepted_out) *drafter_accepted_out = 0;
+    if (text_out && text_cap > 0) text_out[0] = '\\0';
+    if (!stream || !stream->lctx || !stream->sampler) {
+        eliza_set_error(out_error, "[libelizainference] llm_stream_next: invalid session");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+    if (!tokens_out || tokens_cap == 0 || !text_out || text_cap == 0) {
+        eliza_set_error(out_error, "[libelizainference] llm_stream_next: output buffers are required");
+        return ELIZA_ERR_INVALID_ARG;
+    }
+    if (stream->eos) return 1;
+    const llama_model * model = llama_get_model(stream->lctx);
+    const llama_vocab * vocab = llama_model_get_vocab(model);
+    std::string text;
+    size_t produced = 0;
+    size_t step_cap = tokens_cap;
+    if (stream->max_tokens > 0) {
+        const size_t remaining = (size_t) std::max(0, stream->max_tokens - stream->generated);
+        if (remaining == 0) { stream->eos = true; return 1; }
+        step_cap = std::min(step_cap, remaining);
+    }
+    bool final_step = false;
+    while (produced < step_cap) {
+        if (stream->cancel.load(std::memory_order_acquire)) {
+            eliza_set_error(out_error, "[libelizainference] llm_stream_next: cancelled");
+            return ELIZA_ERR_CANCELLED;
+        }
+        llama_token token = llama_sampler_sample(stream->sampler, stream->lctx, -1);
+        if (llama_vocab_is_eog(vocab, token)) { stream->eos = true; final_step = true; break; }
+        std::string piece = eliza_llama_token_piece(vocab, token);
+        if (!piece.empty() && text.size() + piece.size() + 1 > text_cap) break;
+        /* llama_sampler_sample already accepted the token (advancing the
+         * grammar stack); do NOT accept again or the grammar stack empties. */
+        tokens_out[produced] = (int32_t) token;
+        text += piece;
+        produced += 1;
+        stream->generated += 1;
+        llama_batch batch = llama_batch_get_one(&token, 1);
+        int32_t rc = llama_decode(stream->lctx, batch);
+        if (rc != 0) {
+            eliza_set_error(out_error,
+                "[libelizainference] llm_stream_next: llama_decode failed rc=" +
+                std::to_string(rc));
+            return ELIZA_ERR_FFI_FAULT;
+        }
+        stream->n_past += 1;
+        if (stream->max_tokens > 0 && stream->generated >= stream->max_tokens) {
+            stream->eos = true; final_step = true; break;
+        }
+    }
+    if (text.size() + 1 > text_cap) text.resize(text_cap - 1);
+    std::memcpy(text_out, text.data(), text.size());
+    text_out[text.size()] = '\\0';
+    if (num_tokens_out) *num_tokens_out = produced;
+    return final_step ? 1 : 0;
+}
+
+int eliza_inference_llm_stream_cancel(EliLlmStream * stream) {
+    if (stream) stream->cancel.store(true, std::memory_order_release);
+    return ELIZA_OK;
+}
+
+int eliza_inference_llm_stream_save_slot(
+    EliLlmStream * stream, const char * filename, char ** out_error) {
+    (void) stream; (void) filename;
+    eliza_set_error(out_error,
+        "[libelizainference] llm_stream_save_slot is not implemented in this build");
+    return ELIZA_ERR_INVALID_ARG;
+}
+
+int eliza_inference_llm_stream_restore_slot(
+    EliLlmStream * stream, const char * filename, char ** out_error) {
+    (void) stream; (void) filename;
+    eliza_set_error(out_error,
+        "[libelizainference] llm_stream_restore_slot is not implemented in this build");
+    return ELIZA_ERR_INVALID_ARG;
+}
+
+void eliza_inference_llm_stream_close(EliLlmStream * stream) {
+    if (!stream) return;
+    if (stream->sampler) { llama_sampler_free(stream->sampler); stream->sampler = nullptr; }
+    if (stream->lctx) { llama_free(stream->lctx); stream->lctx = nullptr; }
+    delete stream;
+}
+
+void eliza_inference_free_string(char * str) {
+    std::free(str);
+}
+
+} // extern "C"
+`,
+    "utf8",
+  );
+}
+
+function hasFunctionDeclaration(source, name) {
+  return new RegExp(`\\b${name}\\s*\\(`).test(source);
+}
+
+function hasFunctionDefinition(source, name) {
+  return new RegExp(`(?:^|\\n)[^\\n;{}]*\\b${name}\\s*\\(`).test(source);
+}
+
+function inspectPreparedOmnivoiceSurface({ graftRoot }) {
+  const srcRoot = path.join(graftRoot, "src");
+  const headerPath = path.join(srcRoot, "omnivoice.h");
+  const implPath = path.join(srcRoot, "omnivoice.cpp");
+  const adapterPath = path.join(srcRoot, "eliza-inference-ffi.cpp");
+  for (const file of [headerPath, implPath, adapterPath]) {
+    if (!fs.existsSync(file)) {
+      throw new Error(
+        `[omnivoice-fuse] prepared graft missing ${file}; refusing stub-only fusion`,
+      );
+    }
+  }
+
+  const header = fs.readFileSync(headerPath, "utf8");
+  const impl = fs.readFileSync(implPath, "utf8");
+  const adapter = fs.readFileSync(adapterPath, "utf8");
+  const missingHeaderSymbols = REQUIRED_PUBLIC_OMNIVOICE_SYMBOLS.filter(
+    (symbol) => !hasFunctionDeclaration(header, symbol),
+  );
+  if (missingHeaderSymbols.length > 0) {
+    throw new Error(
+      `[omnivoice-fuse] prepared omnivoice.h missing required public symbol(s): ${missingHeaderSymbols.join(", ")}. Pin is not compatible with libelizainference ABI v1.`,
     );
   }
-  return result.stdout?.trim() ?? "";
+
+  const missingImplSymbols = REQUIRED_PUBLIC_OMNIVOICE_SYMBOLS.filter(
+    (symbol) => !hasFunctionDefinition(impl, symbol),
+  );
+  if (missingImplSymbols.length > 0) {
+    throw new Error(
+      `[omnivoice-fuse] prepared omnivoice.cpp missing required implementation symbol(s): ${missingImplSymbols.join(", ")}. Refusing to build a header-only or stub-only graft.`,
+    );
+  }
+
+  const adapterRequiredCalls = [
+    "ov_init_default_params",
+    "ov_init",
+    "ov_free",
+    "ov_tts_default_params",
+    "ov_synthesize",
+    "ov_audio_free",
+    "ov_last_error",
+    "eliza_inference_asr_transcribe",
+    "mtmd_init_from_file",
+    "mtmd_tokenize",
+    "mtmd_helper_eval_chunks",
+    "llama_decode",
+    "llama_sampler_sample",
+  ];
+  const missingAdapterCalls = adapterRequiredCalls.filter(
+    (symbol) => !hasFunctionDeclaration(adapter, symbol),
+  );
+  if (missingAdapterCalls.length > 0) {
+    throw new Error(
+      `[omnivoice-fuse] generated libelizainference adapter is not wired to OmniVoice call(s): ${missingAdapterCalls.join(", ")}`,
+    );
+  }
+
+  return {
+    header: path.relative(graftRoot, headerPath),
+    implementation: path.relative(graftRoot, implPath),
+    adapter: path.relative(graftRoot, adapterPath),
+    requiredPublicSymbols: [...REQUIRED_PUBLIC_OMNIVOICE_SYMBOLS],
+  };
 }
 
-function copyDirRecursive(src, dst) {
-  fs.mkdirSync(dst, { recursive: true });
-  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
-    const from = path.join(src, entry.name);
-    const to = path.join(dst, entry.name);
-    if (entry.isDirectory()) {
-      copyDirRecursive(from, to);
-    } else if (entry.isFile() || entry.isSymbolicLink()) {
-      fs.copyFileSync(from, to);
+function replaceOmnivoiceAnchor(source, from, to, label) {
+  if (!source.includes(from)) {
+    throw new Error(
+      `[omnivoice-fuse] compatibility patch anchor not found: ${label}`,
+    );
+  }
+  return source.replace(from, to);
+}
+
+function applyOmnivoiceReferenceEncodeApi({ graftRoot }) {
+  const srcRoot = path.join(graftRoot, "src");
+
+  const ttsHeaderPath = path.join(srcRoot, "pipeline-tts.h");
+  let ttsHeader = fs.readFileSync(ttsHeaderPath, "utf8");
+  if (!ttsHeader.includes("pipeline_tts_encode_reference")) {
+    const anchor = `int pipeline_tts_duration_sec_to_tokens(const PipelineCodec * pc, float duration_sec);
+
+// Public TTS synthesis entry.`;
+    const replacement = `int pipeline_tts_duration_sec_to_tokens(const PipelineCodec * pc, float duration_sec);
+
+// Encode a 24 kHz mono reference waveform into row-major [K, ref_T] RVQ
+// tokens using the same HuBERT + codec preprocessing path as synthesis.
+// Returns an empty vector and sets ov_last_error on failure.
+std::vector<int32_t> pipeline_tts_encode_reference(PipelineTTS *     pt,
+                                                   PipelineCodec *   pc,
+                                                   const float *     ref_audio_24k,
+                                                   int               ref_n_samples,
+                                                   int *             out_K,
+                                                   int *             out_ref_T,
+                                                   const char *      dump_dir = nullptr);
+
+// Public TTS synthesis entry.`;
+    ttsHeader = replaceOmnivoiceAnchor(
+      ttsHeader,
+      anchor,
+      replacement,
+      "pipeline-tts.h reference encode declaration",
+    );
+    fs.writeFileSync(ttsHeaderPath, ttsHeader, "utf8");
+  }
+
+  const ttsImplPath = path.join(srcRoot, "pipeline-tts.cpp");
+  let ttsImpl = fs.readFileSync(ttsImplPath, "utf8");
+  if (!ttsImpl.includes("pipeline_tts_encode_reference")) {
+    const anchor = `    return r;
+}
+
+ov_status pipeline_tts_synthesize(`;
+    const replacement = `    return r;
+}
+
+std::vector<int32_t> pipeline_tts_encode_reference(PipelineTTS * pt,
+                                                   PipelineCodec * pc,
+                                                   const float * ref_audio_24k,
+                                                   int ref_n_samples,
+                                                   int * out_K,
+                                                   int * out_ref_T,
+                                                   const char * dump_dir) {
+    if (!pt || !pc || !ref_audio_24k || ref_n_samples <= 0) {
+        ov_set_error("pipeline_tts_encode_reference : invalid arguments");
+        return {};
+    }
+
+    RefEncoded re = tts_encode_ref(pt, pc, ref_audio_24k, ref_n_samples,
+                                   "", true, dump_dir);
+    if (!re.has_ref || re.ref_codes.empty()) {
+        ov_set_error("pipeline_tts_encode_reference : reference encoding failed");
+        return {};
+    }
+
+    if (out_K) {
+        *out_K = pt->lm.num_audio_codebook;
+    }
+    if (out_ref_T) {
+        *out_ref_T = re.ref_T;
+    }
+    return re.ref_codes;
+}
+
+ov_status pipeline_tts_synthesize(`;
+    ttsImpl = replaceOmnivoiceAnchor(
+      ttsImpl,
+      anchor,
+      replacement,
+      "pipeline-tts.cpp reference encode implementation",
+    );
+    fs.writeFileSync(ttsImplPath, ttsImpl, "utf8");
+  }
+
+  const headerPath = path.join(srcRoot, "omnivoice.h");
+  let header = fs.readFileSync(headerPath, "utf8");
+  if (!header.includes("ov_encode_reference")) {
+    const anchor = `OV_API enum ov_status ov_synthesize(struct ov_context * ov, const struct ov_tts_params * params, struct ov_audio * out);
+
+// Convert a duration in seconds to a frame count using the bundled codec`;
+    const replacement = `OV_API enum ov_status ov_synthesize(struct ov_context * ov, const struct ov_tts_params * params, struct ov_audio * out);
+
+// Encode a 24 kHz mono fp32 reference waveform through the OmniVoice
+// tokenizer and return row-major [K, ref_T] int32 RVQ tokens. The returned
+// buffer is malloc-allocated by the library and must be released with free()
+// by callers that bind this low-level OmniVoice ABI directly.
+OV_API enum ov_status ov_encode_reference(struct ov_context * ov,
+                                          const float * pcm,
+                                          int n_samples,
+                                          int32_t ** out_tokens,
+                                          int * out_K,
+                                          int * out_ref_T);
+
+// Convert a duration in seconds to a frame count using the bundled codec`;
+    header = replaceOmnivoiceAnchor(
+      header,
+      anchor,
+      replacement,
+      "omnivoice.h reference encode declaration",
+    );
+    fs.writeFileSync(headerPath, header, "utf8");
+  }
+
+  const implPath = path.join(srcRoot, "omnivoice.cpp");
+  let impl = fs.readFileSync(implPath, "utf8");
+  if (!impl.includes("#include <vector>")) {
+    impl = replaceOmnivoiceAnchor(
+      impl,
+      "#include <string>\n",
+      "#include <string>\n#include <vector>\n",
+      "omnivoice.cpp vector include",
+    );
+  }
+  if (!impl.includes("ov_encode_reference")) {
+    const anchor = `int ov_duration_sec_to_tokens(const struct ov_context * ov, float duration_sec) {`;
+    const replacement = `enum ov_status ov_encode_reference(struct ov_context * ov,
+                                   const float * pcm,
+                                   int n_samples,
+                                   int32_t ** out_tokens,
+                                   int * out_K,
+                                   int * out_ref_T) {
+    if (!ov || !pcm || n_samples <= 0 || !out_tokens || !out_K || !out_ref_T) {
+        ov_set_error("ov_encode_reference : invalid arguments");
+        return OV_STATUS_INVALID_PARAMS;
+    }
+    if (!ov->codec_loaded) {
+        ov_set_error("ov_encode_reference : codec not loaded (pass codec_path to ov_init)");
+        ov_log(OV_LOG_ERROR, "[OmniVoice] ov_encode_reference requires a codec-loaded handle");
+        return OV_STATUS_INVALID_PARAMS;
+    }
+
+    try {
+        int K = 0;
+        int ref_T = 0;
+        std::vector<int32_t> tokens =
+            pipeline_tts_encode_reference(&ov->pt, &ov->pc, pcm, n_samples,
+                                          &K, &ref_T, nullptr);
+        if (tokens.empty() || K <= 0 || ref_T <= 0) {
+            return OV_STATUS_GENERATE_FAILED;
+        }
+        const size_t n_tokens = tokens.size();
+        int32_t * copy = (int32_t *) std::malloc(n_tokens * sizeof(int32_t));
+        if (!copy) {
+            ov_set_error("ov_encode_reference : out of memory");
+            return OV_STATUS_GENERATE_FAILED;
+        }
+        std::memcpy(copy, tokens.data(), n_tokens * sizeof(int32_t));
+        *out_tokens = copy;
+        *out_K = K;
+        *out_ref_T = ref_T;
+        return OV_STATUS_OK;
+    } catch (const std::exception & e) {
+        ov_set_error("%s", e.what());
+        ov_log(OV_LOG_ERROR, "[OmniVoice] %s", e.what());
+        return OV_STATUS_GENERATE_FAILED;
+    }
+}
+
+int ov_duration_sec_to_tokens(const struct ov_context * ov, float duration_sec) {`;
+    impl = replaceOmnivoiceAnchor(
+      impl,
+      anchor,
+      replacement,
+      "omnivoice.cpp reference encode implementation",
+    );
+  }
+  fs.writeFileSync(implPath, impl, "utf8");
+}
+
+function applyElizaGgmlCompatibility({ graftRoot, commit }) {
+  const dacPath = path.join(graftRoot, "src", "dac-decoder.h");
+  let source = fs.readFileSync(dacPath, "utf8");
+  const loadCtw = `// Load ConvTranspose1d weights in eliza ggml's native kernel layout.
+// Source-side layout is (IC, OC, K), represented by ggml as ne=(K, OC, IC).
+// eliza ggml already ships GGML_OP_CONV_TRANSPOSE_1D for CPU/CUDA/Metal/
+// Vulkan, while omnivoice's fork used a private col2im_1d op. Keeping the
+// native layout lets the fused build share the patched eliza ggml without
+// adding a second custom op.
+static void dac_load_ctw(struct ggml_tensor * dst, const GGUFModel & gf, const std::string & name) {
+    struct ggml_tensor * mt = ggml_get_tensor(gf.meta, name.c_str());
+    if (!mt) {
+        ov_throw("[DAC] tensor '%s' not found (conv_t1 weight)", name.c_str());
+    }
+    GGML_ASSERT(dst->type == GGML_TYPE_F16);
+
+    const int    K  = (int) mt->ne[0];
+    const int    OC = (int) mt->ne[1];
+    const int    IC = (int) mt->ne[2];
+    const size_t n  = (size_t) IC * (size_t) OC * (size_t) K;
+
+    GGML_ASSERT(dst->ne[0] == K && dst->ne[1] == OC && dst->ne[2] == IC);
+
+    const void * raw = gf_get_data(gf, name.c_str());
+    if (mt->type == GGML_TYPE_F16) {
+        ggml_backend_tensor_set(dst, raw, 0, n * sizeof(ggml_fp16_t));
+        return;
+    }
+
+    std::vector<float> f32(n);
+    if (mt->type == GGML_TYPE_F32) {
+        memcpy(f32.data(), raw, n * sizeof(float));
+    } else if (mt->type == GGML_TYPE_BF16) {
+        const uint16_t * p = (const uint16_t *) raw;
+        for (size_t i = 0; i < n; i++) {
+            f32[i] = ggml_bf16_to_fp32(*(const ggml_bf16_t *) &p[i]);
+        }
+    } else {
+        const struct ggml_type_traits * tr = ggml_get_type_traits(mt->type);
+        if (!tr || !tr->to_float) {
+            ov_throw("[DAC] unsupported conv_t1 weight type %s for '%s'", ggml_type_name(mt->type), name.c_str());
+        }
+        tr->to_float(raw, f32.data(), (int64_t) n);
+    }
+
+    std::vector<ggml_fp16_t> packed(n);
+    for (size_t i = 0; i < n; i++) {
+        packed[i] = ggml_fp32_to_fp16(f32[i]);
+    }
+    ggml_backend_tensor_set(dst, packed.data(), 0, n * sizeof(ggml_fp16_t));
+}
+
+`;
+  source = replaceBetween(
+    source,
+    "// Pre-permute the ConvTranspose1d weight",
+    "// Allocate one snake pair",
+    loadCtw,
+  );
+
+  const convT = `// ConvTranspose1d using eliza ggml's native GGML_OP_CONV_TRANSPOSE_1D.
+// The upstream omnivoice fork used a private col2im_1d op with padding.
+// eliza's native op requires p0=0, so we crop pad samples from both ends
+// and then apply output_pad to match the original length contract.
+static struct ggml_tensor * dac_conv_t1d(struct ggml_context * ctx,
+                                         struct ggml_tensor *  w,
+                                         struct ggml_tensor *  b,
+                                         struct ggml_tensor *  x,
+                                         int                   stride,
+                                         int                   pad,
+                                         int                   oc,
+                                         int                   output_pad) {
+    struct ggml_tensor * y = ggml_conv_transpose_1d(ctx, w, x, stride, 0, 1);
+    y = ggml_reshape_2d(ctx, y, y->ne[0], y->ne[1]);
+
+    if (pad > 0) {
+        const int64_t cropped = y->ne[0] - 2 * (int64_t) pad;
+        GGML_ASSERT(cropped > 0);
+        GGML_ASSERT(y->ne[1] == oc);
+        y = ggml_view_2d(ctx, y, cropped, y->ne[1], y->nb[1], (size_t) pad * y->nb[0]);
+        y = ggml_cont(ctx, y);
+    }
+
+    if (output_pad > 0) {
+        y = ggml_pad(ctx, y, output_pad, 0, 0, 0);
+    }
+
+    if (b) {
+        struct ggml_tensor * b2d = ggml_reshape_2d(ctx, b, 1, b->ne[0]);
+        y                        = ggml_add(ctx, y, b2d);
+    }
+    return y;
+}
+
+`;
+  source = replaceBetween(
+    source,
+    "// ConvTranspose1d via GEMM + col2im_1d",
+    "// Residual unit forward:",
+    convT,
+  );
+
+  source = source.replace(
+    "b.ctw = ggml_new_tensor_2d(ctx, GGML_TYPE_F16, b.in_ch, b.kernel * b.out_ch);",
+    "b.ctw = ggml_new_tensor_3d(ctx, GGML_TYPE_F16, b.kernel, b.out_ch, b.in_ch);",
+  );
+  source = source.replace(
+    "struct ggml_tensor * ctw;  // [IC, K*OC] bf16",
+    "struct ggml_tensor * ctw;  // [K, OC, IC] bf16",
+  );
+  fs.writeFileSync(dacPath, source, "utf8");
+
+  const codecPath = path.join(graftRoot, "src", "pipeline-codec.cpp");
+  let codecSource = fs.readFileSync(codecPath, "utf8");
+  const codecBackendAnchor = `    pc->bp                 = bp;
+    pc->backend            = bp.backend;
+    ggml_backend_t backend = bp.backend;
+`;
+  if (!codecSource.includes(codecBackendAnchor)) {
+    throw new Error(
+      `[omnivoice-fuse] compatibility patch anchor not found: pipeline-codec backend selection`,
+    );
+  }
+  codecSource = codecSource.replace(
+    codecBackendAnchor,
+    `    // Keep the MaskGIT/LM path on the selected accelerator, but pin the
+    // audio tokenizer / DAC codec to CPU on Apple Metal. The merged eliza
+    // ggml Metal DAC decode graph has been observed to stall immediately
+    // after "[TTS] Decode"; using CPU here keeps one fused process and one
+    // model lifecycle while avoiding the bad Metal codec scheduler path.
+    BackendPair codec_bp = bp;
+    const char * requested_backend =
+        bp.backend ? ggml_backend_name(bp.backend) : "(null)";
+    const bool requested_metal =
+        requested_backend &&
+        (std::strncmp(requested_backend, "MTL", 3) == 0 ||
+         std::strstr(requested_backend, "Metal") != nullptr);
+    if (requested_metal && bp.cpu_backend) {
+        codec_bp.backend = bp.cpu_backend;
+        codec_bp.has_gpu = false;
+        ov_log(OV_LOG_INFO,
+               "[PipelineCodec] Metal codec fallback: requested=%s selected=%s reason=merged-ggml-dac-decode-stall",
+               requested_backend, ggml_backend_name(codec_bp.backend));
     }
+    pc->bp                 = codec_bp;
+    pc->backend            = codec_bp.backend;
+    ggml_backend_t backend = codec_bp.backend;
+`,
+  );
+  const codecSchedulerAnchor = "    pc->sched = backend_sched_new(bp, 4096);";
+  if (!codecSource.includes(codecSchedulerAnchor)) {
+    throw new Error(
+      `[omnivoice-fuse] compatibility patch anchor not found: pipeline-codec scheduler backend`,
+    );
   }
+  codecSource = codecSource.replace(
+    codecSchedulerAnchor,
+    "    pc->sched = backend_sched_new(codec_bp, 4096);",
+  );
+  fs.writeFileSync(codecPath, codecSource, "utf8");
+
+  applyOmnivoiceReferenceEncodeApi({ graftRoot });
+
+  fs.writeFileSync(
+    path.join(graftRoot, "src", "version.h"),
+    `#pragma once\n#define OMNIVOICE_VERSION "${commit.slice(0, 12)} (eliza-fused)"\n`,
+    "utf8",
+  );
+  writeElizaFfiAdapter({ graftRoot, commit });
 }
 
 // Ensure a clone of omnivoice.cpp at OMNIVOICE_REF lives under
@@ -116,9 +2249,7 @@ function readOmnivoiceGgmlSubmoduleCommit(checkoutDir) {
     stdio: ["ignore", "pipe", "pipe"],
   });
   if (result.status !== 0) return null;
-  const match = /^160000\s+commit\s+([0-9a-f]{40})/.exec(
-    result.stdout || "",
-  );
+  const match = /^160000\s+commit\s+([0-9a-f]{40})/.exec(result.stdout || "");
   return match ? match[1] : null;
 }
 
@@ -151,6 +2282,355 @@ function applyPatches({ patchesDir, llamaCppRoot }) {
   return applied;
 }
 
+const QWEN3A_MODEL_CPP = `#include "models.h"
+
+ggml_cgraph * clip_graph_qwen3a::build() {
+    ggml_tensor * inp = build_inp_raw(1);
+
+    {
+        inp = ggml_conv_2d(ctx0, model.conv2d_1_w, inp, 2, 2, 1, 1, 1, 1);
+        inp = ggml_add(ctx0, inp, model.conv2d_1_b);
+        inp = ggml_gelu_erf(ctx0, inp);
+
+        inp = ggml_conv_2d(ctx0, model.conv2d_2_w, inp, 2, 2, 1, 1, 1, 1);
+        inp = ggml_add(ctx0, inp, model.conv2d_2_b);
+        inp = ggml_gelu_erf(ctx0, inp);
+
+        inp = ggml_conv_2d(ctx0, model.conv2d_3_w, inp, 2, 2, 1, 1, 1, 1);
+        inp = ggml_add(ctx0, inp, model.conv2d_3_b);
+        inp = ggml_gelu_erf(ctx0, inp);
+
+        cb(inp, "after_conv_blocks", -1);
+
+        const int64_t n_pos_after_conv = inp->ne[0];
+        const int64_t n_mel_after_conv = inp->ne[1];
+
+        inp = ggml_cont(ctx0, ggml_permute(ctx0, inp, 0, 2, 3, 1));
+        inp = ggml_reshape_2d(ctx0, inp, n_pos_after_conv, n_mel_after_conv * inp->ne[3]);
+        inp = ggml_cont(ctx0, ggml_transpose(ctx0, inp));
+
+        inp = ggml_mul_mat(ctx0, model.conv_out_w, inp);
+        if (model.conv_out_b) {
+            inp = ggml_add(ctx0, inp, model.conv_out_b);
+        }
+        cb(inp, "after_conv_out", -1);
+    }
+
+    auto n_pos = inp->ne[1];
+    ggml_tensor * pos_embd_selected = ggml_view_2d(
+        ctx0, model.position_embeddings,
+        model.position_embeddings->ne[0], n_pos,
+        model.position_embeddings->nb[1], 0);
+
+    ggml_tensor * cur = build_vit(
+        inp,
+        n_pos,
+        NORM_TYPE_NORMAL,
+        hparams.ffn_op,
+        pos_embd_selected,
+        nullptr);
+
+    cb(cur, "after_transformer", -1);
+
+    cur = build_ffn(cur,
+        model.mm_1_w, model.mm_1_b,
+        nullptr, nullptr,
+        model.mm_2_w, model.mm_2_b,
+        FFN_GELU_ERF,
+        -1);
+
+    cb(cur, "projected", -1);
+    ggml_build_forward_expand(gf, cur);
+    return gf;
+}
+`;
+
+function replaceRequired(source, from, to, label) {
+  if (!source.includes(from)) {
+    throw new Error(`[omnivoice-fuse] qwen3a patch anchor not found: ${label}`);
+  }
+  return source.replace(from, to);
+}
+
+function applyElizaQwen3AsrMtmdSupport({ llamaCppRoot }) {
+  const touched = [];
+
+  const clipImplPath = path.join(llamaCppRoot, "tools", "mtmd", "clip-impl.h");
+  let clipImpl = fs.readFileSync(clipImplPath, "utf8");
+  if (!clipImpl.includes("PROJECTOR_TYPE_QWEN3A")) {
+    clipImpl = replaceRequired(
+      clipImpl,
+      "    PROJECTOR_TYPE_QWEN2A,\n    PROJECTOR_TYPE_GLMA,",
+      "    PROJECTOR_TYPE_QWEN2A,\n    PROJECTOR_TYPE_QWEN3A,\n    PROJECTOR_TYPE_GLMA,",
+      "clip-impl enum",
+    );
+  }
+  if (!clipImpl.includes('{ PROJECTOR_TYPE_QWEN3A,    "qwen3a"}')) {
+    clipImpl = replaceRequired(
+      clipImpl,
+      '    { PROJECTOR_TYPE_QWEN2A,    "qwen2a"},\n    { PROJECTOR_TYPE_GLMA,      "glma"},',
+      '    { PROJECTOR_TYPE_QWEN2A,    "qwen2a"},\n    { PROJECTOR_TYPE_QWEN3A,    "qwen3a"},\n    { PROJECTOR_TYPE_GLMA,      "glma"},',
+      "clip-impl name map",
+    );
+  }
+  if (!clipImpl.includes("#define TN_CONV2D")) {
+    clipImpl = replaceRequired(
+      clipImpl,
+      '#define TN_CONV1D       "a.conv1d.%d.%s"\n#define TN_MM_AUDIO_MLP',
+      '#define TN_CONV1D       "a.conv1d.%d.%s"\n#define TN_CONV2D       "a.conv2d.%d.%s"\n#define TN_CONV_OUT     "a.conv_out.%s"\n#define TN_MM_AUDIO_MLP',
+      "clip-impl conv2d tensor names",
+    );
+  }
+  if (clipImpl !== fs.readFileSync(clipImplPath, "utf8")) {
+    fs.writeFileSync(clipImplPath, clipImpl, "utf8");
+    touched.push("tools/mtmd/clip-impl.h");
+  }
+
+  const clipModelPath = path.join(
+    llamaCppRoot,
+    "tools",
+    "mtmd",
+    "clip-model.h",
+  );
+  let clipModel = fs.readFileSync(clipModelPath, "utf8");
+  if (!clipModel.includes("conv_out_w")) {
+    clipModel = replaceRequired(
+      clipModel,
+      "    ggml_tensor * conv1d_2_w = nullptr;\n    ggml_tensor * conv1d_2_b = nullptr;\n    ggml_tensor * mm_norm_pre_w = nullptr;",
+      "    ggml_tensor * conv1d_2_w = nullptr;\n    ggml_tensor * conv1d_2_b = nullptr;\n    ggml_tensor * conv_out_w = nullptr;\n    ggml_tensor * conv_out_b = nullptr;\n    ggml_tensor * mm_norm_pre_w = nullptr;",
+      "clip-model conv_out fields",
+    );
+  }
+  if (!clipModel.includes("// qwen3a")) {
+    clipModel = replaceRequired(
+      clipModel,
+      "    ggml_tensor * mm_norm_mid_w = nullptr;\n\n    // cogvlm",
+      "    ggml_tensor * mm_norm_mid_w = nullptr;\n\n    // qwen3a\n    ggml_tensor * conv2d_1_w = nullptr;\n    ggml_tensor * conv2d_1_b = nullptr;\n    ggml_tensor * conv2d_2_w = nullptr;\n    ggml_tensor * conv2d_2_b = nullptr;\n    ggml_tensor * conv2d_3_w = nullptr;\n    ggml_tensor * conv2d_3_b = nullptr;\n\n    // cogvlm",
+      "clip-model qwen3a fields",
+    );
+  }
+  if (clipModel !== fs.readFileSync(clipModelPath, "utf8")) {
+    fs.writeFileSync(clipModelPath, clipModel, "utf8");
+    touched.push("tools/mtmd/clip-model.h");
+  }
+
+  const modelsHeaderPath = path.join(
+    llamaCppRoot,
+    "tools",
+    "mtmd",
+    "models",
+    "models.h",
+  );
+  let modelsHeader = fs.readFileSync(modelsHeaderPath, "utf8");
+  if (!modelsHeader.includes("clip_graph_qwen3a")) {
+    modelsHeader = replaceRequired(
+      modelsHeader,
+      "struct clip_graph_kimik25 : clip_graph {",
+      "struct clip_graph_qwen3a : clip_graph {\n    clip_graph_qwen3a(clip_ctx * ctx, const clip_image_f32 & img) : clip_graph(ctx, img) {}\n    ggml_cgraph * build() override;\n};\n\nstruct clip_graph_kimik25 : clip_graph {",
+      "models.h qwen3a graph declaration",
+    );
+    fs.writeFileSync(modelsHeaderPath, modelsHeader, "utf8");
+    touched.push("tools/mtmd/models/models.h");
+  }
+
+  const qwen3aPath = path.join(
+    llamaCppRoot,
+    "tools",
+    "mtmd",
+    "models",
+    "qwen3a.cpp",
+  );
+  if (!fs.existsSync(qwen3aPath)) {
+    fs.writeFileSync(qwen3aPath, QWEN3A_MODEL_CPP, "utf8");
+    touched.push("tools/mtmd/models/qwen3a.cpp");
+  }
+
+  const mtmdCmakePath = path.join(
+    llamaCppRoot,
+    "tools",
+    "mtmd",
+    "CMakeLists.txt",
+  );
+  let mtmdCmake = fs.readFileSync(mtmdCmakePath, "utf8");
+  if (!mtmdCmake.includes("models/qwen3a.cpp")) {
+    mtmdCmake = replaceRequired(
+      mtmdCmake,
+      "            models/qwen3vl.cpp\n            models/siglip.cpp",
+      "            models/qwen3vl.cpp\n            models/qwen3a.cpp\n            models/siglip.cpp",
+      "mtmd CMake qwen3a source",
+    );
+    fs.writeFileSync(mtmdCmakePath, mtmdCmake, "utf8");
+    touched.push("tools/mtmd/CMakeLists.txt");
+  }
+
+  const clipPath = path.join(llamaCppRoot, "tools", "mtmd", "clip.cpp");
+  let clip = fs.readFileSync(clipPath, "utf8");
+  const qwen3aDispatchBlock = `        case PROJECTOR_TYPE_QWEN3A:
+            {
+                builder = std::make_unique<clip_graph_qwen3a>(ctx, img);
+            } break;
+`;
+  const firstQwen3aDispatch = clip.indexOf(qwen3aDispatchBlock);
+  const secondQwen3aDispatch =
+    firstQwen3aDispatch >= 0
+      ? clip.indexOf(
+          qwen3aDispatchBlock,
+          firstQwen3aDispatch + qwen3aDispatchBlock.length,
+        )
+      : -1;
+  if (secondQwen3aDispatch >= 0) {
+    clip =
+      clip.slice(0, secondQwen3aDispatch) +
+      clip.slice(secondQwen3aDispatch + qwen3aDispatchBlock.length);
+  }
+  if (!clip.includes("clip_graph_qwen3a")) {
+    clip = replaceRequired(
+      clip,
+      "        case PROJECTOR_TYPE_ULTRAVOX:\n        case PROJECTOR_TYPE_VOXTRAL:\n        case PROJECTOR_TYPE_QWEN2A:",
+      "        case PROJECTOR_TYPE_QWEN3A:\n            {\n                builder = std::make_unique<clip_graph_qwen3a>(ctx, img);\n            } break;\n        case PROJECTOR_TYPE_ULTRAVOX:\n        case PROJECTOR_TYPE_VOXTRAL:\n        case PROJECTOR_TYPE_QWEN2A:",
+      "clip.cpp qwen3a graph dispatch",
+    );
+  }
+  if (
+    !clip.includes(
+      "case PROJECTOR_TYPE_QWEN3A:\n                case PROJECTOR_TYPE_GLMA",
+    )
+  ) {
+    clip = replaceRequired(
+      clip,
+      "                case PROJECTOR_TYPE_QWEN2A:\n                case PROJECTOR_TYPE_GLMA:",
+      "                case PROJECTOR_TYPE_QWEN2A:\n                case PROJECTOR_TYPE_QWEN3A:\n                case PROJECTOR_TYPE_GLMA:",
+      "clip.cpp qwen3a hparams",
+    );
+  }
+  if (
+    !clip.includes(
+      "case PROJECTOR_TYPE_QWEN3A:\n                {\n                    model.conv2d_1_w",
+    )
+  ) {
+    clip = replaceRequired(
+      clip,
+      "            case PROJECTOR_TYPE_VOXTRAL:\n                {",
+      '            case PROJECTOR_TYPE_QWEN3A:\n                {\n                    model.conv2d_1_w = get_tensor(string_format(TN_CONV2D, 1, "weight"));\n                    model.conv2d_1_b = get_tensor(string_format(TN_CONV2D, 1, "bias"));\n                    model.conv2d_2_w = get_tensor(string_format(TN_CONV2D, 2, "weight"));\n                    model.conv2d_2_b = get_tensor(string_format(TN_CONV2D, 2, "bias"));\n                    model.conv2d_3_w = get_tensor(string_format(TN_CONV2D, 3, "weight"));\n                    model.conv2d_3_b = get_tensor(string_format(TN_CONV2D, 3, "bias"));\n                    model.conv_out_w = get_tensor(string_format(TN_CONV_OUT, "weight"));\n                    model.conv_out_b = get_tensor(string_format(TN_CONV_OUT, "bias"), false);\n                    model.mm_1_w = get_tensor(string_format(TN_MM_AUDIO_MLP, 1, "weight"));\n                    model.mm_1_b = get_tensor(string_format(TN_MM_AUDIO_MLP, 1, "bias"));\n                    model.mm_2_w = get_tensor(string_format(TN_MM_AUDIO_MLP, 2, "weight"));\n                    model.mm_2_b = get_tensor(string_format(TN_MM_AUDIO_MLP, 2, "bias"));\n                } break;\n            case PROJECTOR_TYPE_VOXTRAL:\n                {',
+      "clip.cpp qwen3a tensor loads",
+    );
+  }
+  if (
+    !clip.includes(
+      "case PROJECTOR_TYPE_QWEN3A:\n            {\n                // 3x stride-2 conv2d",
+    )
+  ) {
+    clip = replaceRequired(
+      clip,
+      "        case PROJECTOR_TYPE_GLMA:\n            {",
+      "        case PROJECTOR_TYPE_QWEN3A:\n            {\n                // 3x stride-2 conv2d: each step is floor((n-1)/2)+1\n                int n = img->nx;\n                n = (n - 1) / 2 + 1;\n                n = (n - 1) / 2 + 1;\n                n = (n - 1) / 2 + 1;\n                n_patches = n;\n            } break;\n        case PROJECTOR_TYPE_GLMA:\n            {",
+      "clip.cpp qwen3a output token count",
+    );
+  }
+  if (
+    !clip.includes(
+      "case PROJECTOR_TYPE_QWEN3A:\n        case PROJECTOR_TYPE_GLMA:\n        case PROJECTOR_TYPE_ULTRAVOX",
+    )
+  ) {
+    clip = replaceRequired(
+      clip,
+      "        case PROJECTOR_TYPE_QWEN2A:\n        case PROJECTOR_TYPE_GLMA:\n        case PROJECTOR_TYPE_ULTRAVOX:",
+      "        case PROJECTOR_TYPE_QWEN2A:\n        case PROJECTOR_TYPE_QWEN3A:\n        case PROJECTOR_TYPE_GLMA:\n        case PROJECTOR_TYPE_ULTRAVOX:",
+      "clip.cpp qwen3a input setup",
+    );
+  }
+  if (
+    !clip.includes(
+      "case PROJECTOR_TYPE_QWEN3A:\n            return ctx->model.mm_2_w->ne[1];",
+    )
+  ) {
+    clip = replaceRequired(
+      clip,
+      "        case PROJECTOR_TYPE_QWEN2A:\n            return ctx->model.mm_fc_w->ne[1];\n        case PROJECTOR_TYPE_GLMA:",
+      "        case PROJECTOR_TYPE_QWEN2A:\n            return ctx->model.mm_fc_w->ne[1];\n        case PROJECTOR_TYPE_QWEN3A:\n            return ctx->model.mm_2_w->ne[1];\n        case PROJECTOR_TYPE_GLMA:",
+      "clip.cpp qwen3a mmproj embedding dim",
+    );
+  }
+  if (
+    !clip.includes(
+      "case PROJECTOR_TYPE_QWEN3A:\n        case PROJECTOR_TYPE_GLMA:\n        case PROJECTOR_TYPE_VOXTRAL",
+    )
+  ) {
+    clip = replaceRequired(
+      clip,
+      "        case PROJECTOR_TYPE_QWEN2A:\n        case PROJECTOR_TYPE_GLMA:\n        case PROJECTOR_TYPE_VOXTRAL:",
+      "        case PROJECTOR_TYPE_QWEN2A:\n        case PROJECTOR_TYPE_QWEN3A:\n        case PROJECTOR_TYPE_GLMA:\n        case PROJECTOR_TYPE_VOXTRAL:",
+      "clip.cpp qwen3a whisper preprocessor flag",
+    );
+  }
+  if (clip !== fs.readFileSync(clipPath, "utf8")) {
+    fs.writeFileSync(clipPath, clip, "utf8");
+    touched.push("tools/mtmd/clip.cpp");
+  }
+
+  const mtmdPath = path.join(llamaCppRoot, "tools", "mtmd", "mtmd.cpp");
+  let mtmd = fs.readFileSync(mtmdPath, "utf8");
+  if (
+    !mtmd.includes(
+      "case PROJECTOR_TYPE_QWEN3A:\n            case PROJECTOR_TYPE_QWEN25O:",
+    )
+  ) {
+    mtmd = replaceRequired(
+      mtmd,
+      "            case PROJECTOR_TYPE_QWEN2A:\n            case PROJECTOR_TYPE_QWEN25O:",
+      "            case PROJECTOR_TYPE_QWEN2A:\n            case PROJECTOR_TYPE_QWEN3A:\n            case PROJECTOR_TYPE_QWEN25O:",
+      "mtmd.cpp qwen3a audio preprocessor",
+    );
+  }
+  // Detect "already applied" in two flavors:
+  //   (a) This patch ran on a clean fork that originally had a QWEN2A-only
+  //       audio_bos/eos branch → patcher inserted a new QWEN3A branch with
+  //       <|audio_start|>/<|audio_end|>.
+  //   (b) The fork itself merged QWEN3A under the QWEN2A/QWEN25O audio_bos/eos
+  //       branch (fork commit 2f80716c "updates" in v1.1.x+). In that case the
+  //       fork has decided QWEN3A uses audio_bos/eos like QWEN2A, and this
+  //       eliza-side backport must NOT try to splice in audio_start/end on top
+  //       — there is no QWEN2A-only anchor left to replace, and the operator
+  //       fork has chosen the token strings. Treat as already applied.
+  const variantA =
+    mtmd.includes('aud_beg = "<|audio_start|>";') &&
+    mtmd.includes("proj == PROJECTOR_TYPE_QWEN3A");
+  const variantB = mtmd.includes(
+    "if (proj == PROJECTOR_TYPE_QWEN2A || proj == PROJECTOR_TYPE_QWEN3A || proj == PROJECTOR_TYPE_QWEN25O) {",
+  );
+  if (!variantA && !variantB) {
+    mtmd = replaceRequired(
+      mtmd,
+      `        if (proj == PROJECTOR_TYPE_QWEN2A) {
+            // <|audio_bos|> ... (embeddings) ... <|audio_eos|>
+            aud_beg = "<|audio_bos|>";
+            aud_end = "<|audio_eos|>";
+`,
+      `        if (proj == PROJECTOR_TYPE_QWEN3A) {
+            // <|audio_start|> ... (embeddings replacing <|audio_pad|>) ... <|audio_end|>
+            aud_beg = "<|audio_start|>";
+            aud_end = "<|audio_end|>";
+
+        } else if (proj == PROJECTOR_TYPE_QWEN2A || proj == PROJECTOR_TYPE_QWEN25O) {
+            // <|audio_bos|> ... (embeddings) ... <|audio_eos|>
+            aud_beg = "<|audio_bos|>";
+            aud_end = "<|audio_eos|>";
+`,
+      "mtmd.cpp qwen3a audio special tokens",
+    );
+  }
+  if (mtmd !== fs.readFileSync(mtmdPath, "utf8")) {
+    fs.writeFileSync(mtmdPath, mtmd, "utf8");
+    touched.push("tools/mtmd/mtmd.cpp");
+  }
+
+  return {
+    name: "eliza-qwen3a-mtmd-backport",
+    status: touched.length > 0 ? "applied" : "already-applied",
+    files: touched,
+  };
+}
+
 /**
  * Main entry. Performs the full prepare phase. All errors propagate.
  */
@@ -169,7 +2649,7 @@ export function prepareOmnivoiceFusion({
   }
   if (!fs.existsSync(path.join(llamaCppRoot, "ggml", "CMakeLists.txt"))) {
     throw new Error(
-      `[omnivoice-fuse] llamaCppRoot=${llamaCppRoot} missing ggml/CMakeLists.txt; the milady ggml is required for fusion`,
+      `[omnivoice-fuse] llamaCppRoot=${llamaCppRoot} missing ggml/CMakeLists.txt; the eliza ggml is required for fusion`,
     );
   }
 
@@ -214,6 +2694,8 @@ export function prepareOmnivoiceFusion({
       path.join(graftRoot, subdir),
     );
   }
+  applyElizaGgmlCompatibility({ graftRoot, commit: head });
+  const sourceSurface = inspectPreparedOmnivoiceSurface({ graftRoot });
 
   // examples/ is data-only (audio prompts, sample text). Copy on a
   // best-effort basis — the build does not depend on these files. We
@@ -235,7 +2717,43 @@ export function prepareOmnivoiceFusion({
 
   // Apply any reconciliation patches keyed to specific drifts.
   const patchesDir = new URL("./patches/", import.meta.url).pathname;
-  const appliedPatches = applyPatches({ patchesDir, llamaCppRoot });
+  const qwen3aBackport = applyElizaQwen3AsrMtmdSupport({ llamaCppRoot });
+  const appliedPatches = [
+    qwen3aBackport,
+    ...applyPatches({ patchesDir, llamaCppRoot }),
+  ];
+
+  // Stage the Kokoro graft alongside OmniVoice. The Kokoro sources live in
+  // `packages/app-core/scripts/omnivoice-fuse/kokoro-graft/{src,tools}` and
+  // are copied into the same `omnivoice/` directory so they compile into the
+  // same `omnivoice-core` static library + `elizainference` shared library.
+  // See kokoro-llama-cpp-feasibility.md §3.
+  const kokoroStagingDir = new URL("./kokoro-graft/", import.meta.url).pathname;
+  let kokoroSourceCount = 0;
+  if (fs.existsSync(kokoroStagingDir)) {
+    for (const subdir of ["src", "tools"]) {
+      const from = path.join(kokoroStagingDir, subdir);
+      const to = path.join(graftRoot, subdir);
+      if (!fs.existsSync(from)) continue;
+      for (const entry of fs.readdirSync(from, { withFileTypes: true })) {
+        // Only copy kokoro-* and convert_kokoro_* files; never overwrite
+        // OmniVoice's own files in src/ or tools/. The CMake graft block
+        // globs `kokoro-*.cpp` specifically so the two sets stay
+        // distinguishable on the build side.
+        if (
+          !entry.name.startsWith("kokoro") &&
+          !entry.name.startsWith("convert_kokoro")
+        ) {
+          continue;
+        }
+        if (entry.isDirectory()) continue;
+        const srcFile = path.join(from, entry.name);
+        const dstFile = path.join(to, entry.name);
+        fs.copyFileSync(srcFile, dstFile);
+        if (/\.(c|cc|cpp|cxx|h|hpp)$/.test(entry.name)) kokoroSourceCount += 1;
+      }
+    }
+  }
 
   // Count source files actually grafted, for the manifest.
   let sourceCount = 0;
@@ -258,6 +2776,8 @@ export function prepareOmnivoiceFusion({
     ggmlSubmoduleCommit,
     graftRoot,
     sourceCount,
+    sourceSurface,
     appliedPatches,
+    kokoroSourceCount,
   };
 }