@elizaos/plugin-capacitor-bridge 2.0.3-beta.2 → 2.0.3-beta.4

package/dist/ios/bridge.js

@@ -0,0 +1,2913 @@
+import {
+  installMobileFsShim,
+  wrapMobileFsOpen,
+  wrapMobileFsPath,
+  wrapMobileFsTwoPaths
+} from "../chunk-E7Y447TQ.js";
+import {
+  __export
+} from "../chunk-MLKGABMK.js";
+
+// src/ios/bridge.ts
+import { Buffer } from "buffer";
+import crypto from "crypto";
+import path from "path";
+import process2 from "process";
+import { Readable } from "stream";
+import {
+  ChannelType,
+  createMessageMemory,
+  ModelType,
+  stringToUuid
+} from "@elizaos/core";
+
+// src/shared/fs-proxy.ts
+import * as realFs from "fs";
+
+// src/shared/fs-promises-proxy.ts
+var fs_promises_proxy_exports = {};
+__export(fs_promises_proxy_exports, {
+  access: () => access2,
+  appendFile: () => appendFile2,
+  chmod: () => chmod2,
+  chown: () => chown2,
+  copyFile: () => copyFile2,
+  cp: () => cp2,
+  default: () => fs_promises_proxy_default,
+  lchmod: () => lchmod2,
+  lchown: () => lchown2,
+  link: () => link2,
+  lstat: () => lstat2,
+  lutimes: () => lutimes2,
+  mkdir: () => mkdir2,
+  mkdtemp: () => mkdtemp2,
+  open: () => open2,
+  opendir: () => opendir2,
+  readFile: () => readFile2,
+  readdir: () => readdir2,
+  readlink: () => readlink2,
+  realpath: () => realpath2,
+  rename: () => rename2,
+  rm: () => rm2,
+  rmdir: () => rmdir2,
+  stat: () => stat2,
+  symlink: () => symlink2,
+  truncate: () => truncate2,
+  unlink: () => unlink2,
+  utimes: () => utimes2,
+  watch: () => watch2,
+  writeFile: () => writeFile2
+});
+import * as realPromises from "fs/promises";
+var MODULE_NAME = "mobile-fs-promises-proxy";
+function wrapPath(fn, mode) {
+  return wrapMobileFsPath(MODULE_NAME, fn, mode);
+}
+function wrapOpen(fn) {
+  return wrapMobileFsOpen(MODULE_NAME, fn);
+}
+function wrapTwoPaths(fn, srcMode, dstMode) {
+  return wrapMobileFsTwoPaths(MODULE_NAME, fn, srcMode, dstMode);
+}
+var access2 = wrapPath(realPromises.access, "read");
+var appendFile2 = wrapPath(realPromises.appendFile, "write");
+var chmod2 = wrapPath(realPromises.chmod, "write");
+var chown2 = wrapPath(realPromises.chown, "write");
+var copyFile2 = wrapTwoPaths(realPromises.copyFile, "read", "write");
+var cp2 = wrapTwoPaths(realPromises.cp, "read", "write");
+var lchmod2 = wrapPath(realPromises.lchmod, "write");
+var lchown2 = wrapPath(realPromises.lchown, "write");
+var link2 = wrapTwoPaths(realPromises.link, "read", "write");
+var lstat2 = wrapPath(realPromises.lstat, "read");
+var lutimes2 = wrapPath(realPromises.lutimes, "write");
+var mkdir2 = wrapPath(realPromises.mkdir, "write");
+var mkdtemp2 = wrapPath(realPromises.mkdtemp, "write");
+var open2 = wrapOpen(realPromises.open);
+var opendir2 = wrapPath(realPromises.opendir, "read");
+var readdir2 = wrapPath(realPromises.readdir, "read");
+var readFile2 = wrapPath(realPromises.readFile, "read");
+var readlink2 = wrapPath(realPromises.readlink, "read");
+var realpath2 = wrapPath(realPromises.realpath, "read");
+var rename2 = wrapTwoPaths(realPromises.rename, "write", "write");
+var rm2 = wrapPath(realPromises.rm, "write");
+var rmdir2 = wrapPath(realPromises.rmdir, "write");
+var stat2 = wrapPath(realPromises.stat, "read");
+var symlink2 = wrapTwoPaths(realPromises.symlink, "read", "write");
+var truncate2 = wrapPath(realPromises.truncate, "write");
+var unlink2 = wrapPath(realPromises.unlink, "write");
+var utimes2 = wrapPath(realPromises.utimes, "write");
+var watch2 = wrapPath(realPromises.watch, "read");
+var writeFile2 = wrapPath(realPromises.writeFile, "write");
+var promisesDefault = {
+  ...realPromises,
+  access: access2,
+  appendFile: appendFile2,
+  chmod: chmod2,
+  chown: chown2,
+  copyFile: copyFile2,
+  cp: cp2,
+  lchmod: lchmod2,
+  lchown: lchown2,
+  link: link2,
+  lstat: lstat2,
+  lutimes: lutimes2,
+  mkdir: mkdir2,
+  mkdtemp: mkdtemp2,
+  open: open2,
+  opendir: opendir2,
+  readdir: readdir2,
+  readFile: readFile2,
+  readlink: readlink2,
+  realpath: realpath2,
+  rename: rename2,
+  rm: rm2,
+  rmdir: rmdir2,
+  stat: stat2,
+  symlink: symlink2,
+  truncate: truncate2,
+  unlink: unlink2,
+  utimes: utimes2,
+  watch: watch2,
+  writeFile: writeFile2
+};
+var fs_promises_proxy_default = promisesDefault;
+
+// src/shared/fs-proxy.ts
+var MODULE_NAME2 = "mobile-fs-proxy";
+function wrapPath2(fn, mode) {
+  return wrapMobileFsPath(MODULE_NAME2, fn, mode);
+}
+function wrapOpen2(fn) {
+  return wrapMobileFsOpen(MODULE_NAME2, fn);
+}
+function wrapTwoPaths2(fn, srcMode, dstMode) {
+  return wrapMobileFsTwoPaths(MODULE_NAME2, fn, srcMode, dstMode);
+}
+var constants2 = realFs.constants;
+var promises = fs_promises_proxy_exports;
+var access4 = wrapPath2(realFs.access, "read");
+var accessSync2 = wrapPath2(realFs.accessSync, "read");
+var appendFile4 = wrapPath2(realFs.appendFile, "write");
+var appendFileSync2 = wrapPath2(realFs.appendFileSync, "write");
+var chmod4 = wrapPath2(realFs.chmod, "write");
+var chmodSync2 = wrapPath2(realFs.chmodSync, "write");
+var chown4 = wrapPath2(realFs.chown, "write");
+var chownSync2 = wrapPath2(realFs.chownSync, "write");
+var copyFile4 = wrapTwoPaths2(realFs.copyFile, "read", "write");
+var copyFileSync2 = wrapTwoPaths2(realFs.copyFileSync, "read", "write");
+var cp4 = wrapTwoPaths2(realFs.cp, "read", "write");
+var cpSync2 = wrapTwoPaths2(realFs.cpSync, "read", "write");
+var createReadStream2 = wrapPath2(realFs.createReadStream, "read");
+var createWriteStream2 = wrapPath2(realFs.createWriteStream, "write");
+var existsSync2 = wrapPath2(realFs.existsSync, "read");
+var lchmod4 = wrapPath2(realFs.lchmod, "write");
+var lchmodSync2 = wrapPath2(realFs.lchmodSync, "write");
+var lchown4 = wrapPath2(realFs.lchown, "write");
+var lchownSync2 = wrapPath2(realFs.lchownSync, "write");
+var link4 = wrapTwoPaths2(realFs.link, "read", "write");
+var linkSync2 = wrapTwoPaths2(realFs.linkSync, "read", "write");
+var lstat4 = wrapPath2(realFs.lstat, "read");
+var lstatSync2 = wrapPath2(realFs.lstatSync, "read");
+var lutimes4 = wrapPath2(realFs.lutimes, "write");
+var lutimesSync2 = wrapPath2(realFs.lutimesSync, "write");
+var mkdir4 = wrapPath2(realFs.mkdir, "write");
+var mkdirSync2 = wrapPath2(realFs.mkdirSync, "write");
+var mkdtemp4 = wrapPath2(realFs.mkdtemp, "write");
+var mkdtempSync2 = wrapPath2(realFs.mkdtempSync, "write");
+var open4 = wrapOpen2(realFs.open);
+var openSync2 = wrapOpen2(realFs.openSync);
+var opendir4 = wrapPath2(realFs.opendir, "read");
+var opendirSync2 = wrapPath2(realFs.opendirSync, "read");
+var readdir4 = wrapPath2(realFs.readdir, "read");
+var readdirSync2 = wrapPath2(realFs.readdirSync, "read");
+var readFile4 = wrapPath2(realFs.readFile, "read");
+var readFileSync2 = wrapPath2(realFs.readFileSync, "read");
+var readlink4 = wrapPath2(realFs.readlink, "read");
+var readlinkSync2 = wrapPath2(realFs.readlinkSync, "read");
+var realpath4 = wrapPath2(realFs.realpath, "read");
+var realpathSync2 = wrapPath2(realFs.realpathSync, "read");
+var rename4 = wrapTwoPaths2(realFs.rename, "write", "write");
+var renameSync2 = wrapTwoPaths2(realFs.renameSync, "write", "write");
+var rm4 = wrapPath2(realFs.rm, "write");
+var rmSync2 = wrapPath2(realFs.rmSync, "write");
+var rmdir4 = wrapPath2(realFs.rmdir, "write");
+var rmdirSync2 = wrapPath2(realFs.rmdirSync, "write");
+var stat4 = wrapPath2(realFs.stat, "read");
+var statSync2 = wrapPath2(realFs.statSync, "read");
+var symlink4 = wrapTwoPaths2(realFs.symlink, "read", "write");
+var symlinkSync2 = wrapTwoPaths2(realFs.symlinkSync, "read", "write");
+var truncate4 = wrapPath2(realFs.truncate, "write");
+var truncateSync2 = wrapPath2(realFs.truncateSync, "write");
+var unlink4 = wrapPath2(realFs.unlink, "write");
+var unlinkSync2 = wrapPath2(realFs.unlinkSync, "write");
+var utimes4 = wrapPath2(realFs.utimes, "write");
+var utimesSync2 = wrapPath2(realFs.utimesSync, "write");
+var watch4 = wrapPath2(realFs.watch, "read");
+var watchFile2 = wrapPath2(realFs.watchFile, "read");
+var writeFile4 = wrapPath2(realFs.writeFile, "write");
+var writeFileSync2 = wrapPath2(realFs.writeFileSync, "write");
+var fsDefault = {
+  ...realFs,
+  constants: constants2,
+  promises,
+  access: access4,
+  accessSync: accessSync2,
+  appendFile: appendFile4,
+  appendFileSync: appendFileSync2,
+  chmod: chmod4,
+  chmodSync: chmodSync2,
+  chown: chown4,
+  chownSync: chownSync2,
+  copyFile: copyFile4,
+  copyFileSync: copyFileSync2,
+  cp: cp4,
+  cpSync: cpSync2,
+  createReadStream: createReadStream2,
+  createWriteStream: createWriteStream2,
+  existsSync: existsSync2,
+  lchmod: lchmod4,
+  lchmodSync: lchmodSync2,
+  lchown: lchown4,
+  lchownSync: lchownSync2,
+  link: link4,
+  linkSync: linkSync2,
+  lstat: lstat4,
+  lstatSync: lstatSync2,
+  lutimes: lutimes4,
+  lutimesSync: lutimesSync2,
+  mkdir: mkdir4,
+  mkdirSync: mkdirSync2,
+  mkdtemp: mkdtemp4,
+  mkdtempSync: mkdtempSync2,
+  open: open4,
+  openSync: openSync2,
+  opendir: opendir4,
+  opendirSync: opendirSync2,
+  readdir: readdir4,
+  readdirSync: readdirSync2,
+  readFile: readFile4,
+  readFileSync: readFileSync2,
+  readlink: readlink4,
+  readlinkSync: readlinkSync2,
+  realpath: realpath4,
+  realpathSync: realpathSync2,
+  rename: rename4,
+  renameSync: renameSync2,
+  rm: rm4,
+  rmSync: rmSync2,
+  rmdir: rmdir4,
+  rmdirSync: rmdirSync2,
+  stat: stat4,
+  statSync: statSync2,
+  symlink: symlink4,
+  symlinkSync: symlinkSync2,
+  truncate: truncate4,
+  truncateSync: truncateSync2,
+  unlink: unlink4,
+  unlinkSync: unlinkSync2,
+  utimes: utimes4,
+  utimesSync: utimesSync2,
+  watch: watch4,
+  watchFile: watchFile2,
+  writeFile: writeFile4,
+  writeFileSync: writeFileSync2
+};
+
+// src/ios/model-grind.ts
+var GRIND_PHRASE = "Eliza local voice end to end check, one two three.";
+function now() {
+  return typeof performance !== "undefined" ? performance.now() : Number(process.hrtime.bigint() / 1000000n);
+}
+function wordErrorRate(reference, hypothesis) {
+  const norm = (s) => s.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter(Boolean);
+  const ref = norm(reference);
+  const hyp = norm(hypothesis);
+  if (ref.length === 0) return hyp.length === 0 ? 0 : 1;
+  const dp = Array.from({ length: hyp.length + 1 }, (_v, j) => j);
+  for (let i = 1; i <= ref.length; i++) {
+    let prev = dp[0];
+    dp[0] = i;
+    for (let j = 1; j <= hyp.length; j++) {
+      const tmp = dp[j];
+      dp[j] = ref[i - 1] === hyp[j - 1] ? prev : 1 + Math.min(prev, dp[j], dp[j - 1]);
+      prev = tmp;
+    }
+  }
+  return dp[hyp.length] / ref.length;
+}
+function decodeWavToPcm(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (bytes.length < 44 || view.getUint32(0, false) !== 1380533830) {
+    throw new Error("not a RIFF/WAV payload");
+  }
+  let offset = 12;
+  let fmt = 1;
+  let channels = 1;
+  let sampleRate = 24e3;
+  let bitsPerSample = 16;
+  let dataOffset = -1;
+  let dataLen = 0;
+  while (offset + 8 <= bytes.length) {
+    const id = view.getUint32(offset, false);
+    const size = view.getUint32(offset + 4, true);
+    const body = offset + 8;
+    if (id === 1718449184) {
+      fmt = view.getUint16(body, true);
+      channels = view.getUint16(body + 2, true) || 1;
+      sampleRate = view.getUint32(body + 4, true) || 24e3;
+      bitsPerSample = view.getUint16(body + 14, true) || 16;
+    } else if (id === 1684108385) {
+      dataOffset = body;
+      dataLen = size;
+    }
+    offset = body + size + size % 2;
+  }
+  if (dataOffset < 0) throw new Error("WAV has no data chunk");
+  const pcm = [];
+  const isFloat = fmt === 3 || bitsPerSample === 32;
+  const step = bitsPerSample / 8 * channels;
+  for (let p = dataOffset; p + step <= dataOffset + dataLen && p + step <= bytes.length; p += step) {
+    const sample = isFloat ? view.getFloat32(p, true) : view.getInt16(p, true) / 32768;
+    pcm.push(sample);
+  }
+  return { pcm, sampleRate };
+}
+function resamplePcm(pcm, from, to) {
+  if (from === to || pcm.length === 0) return pcm;
+  const ratio = to / from;
+  const out = new Array(Math.max(1, Math.floor(pcm.length * ratio)));
+  for (let i = 0; i < out.length; i++) {
+    const src = i / ratio;
+    const i0 = Math.floor(src);
+    const i1 = Math.min(pcm.length - 1, i0 + 1);
+    const frac = src - i0;
+    out[i] = pcm[i0] * (1 - frac) + pcm[i1] * frac;
+  }
+  return out;
+}
+function availGb(hw) {
+  const v = Number(hw.available_ram_gb ?? hw.free_ram_gb ?? NaN);
+  return Number.isFinite(v) ? v : null;
+}
+async function runModelGrind(deps) {
+  const startedAtEpochMs = Date.now();
+  const t0 = now();
+  const models = [];
+  let device = {};
+  let beforeAvailGb = null;
+  try {
+    device = await deps.hardwareInfo();
+    beforeAvailGb = availGb(device);
+  } catch (error) {
+    device = { error: error instanceof Error ? error.message : String(error) };
+  }
+  let minAvailGb = beforeAvailGb;
+  const trackMem = async () => {
+    try {
+      const a = availGb(await deps.hardwareInfo());
+      if (a !== null && (minAvailGb === null || a < minAvailGb)) minAvailGb = a;
+    } catch {
+    }
+  };
+  {
+    const r = { model: "text", ok: false };
+    let availPreLoad = null;
+    try {
+      availPreLoad = availGb(await deps.hardwareInfo());
+    } catch {
+    }
+    try {
+      const lt = now();
+      const state = await deps.ensureTextModelLoaded("TEXT_SMALL");
+      const contextId = typeof state.contextId === "number" && Number.isFinite(state.contextId) ? state.contextId : null;
+      if (contextId == null) {
+        throw new Error("Text model load returned no contextId");
+      }
+      r.loadMs = Math.round(now() - lt);
+      let availPostLoad = null;
+      try {
+        availPostLoad = availGb(await deps.hardwareInfo());
+      } catch {
+      }
+      r.loadDetail = {
+        loadResult: state,
+        availPreLoadGb: availPreLoad,
+        availPostLoadGb: availPostLoad,
+        loadUsedGb: availPreLoad !== null && availPostLoad !== null ? Math.round((availPreLoad - availPostLoad) * 1e3) / 1e3 : null
+      };
+      const gt = now();
+      const res = await deps.callIosHost(
+        "llama_generate",
+        {
+          context_id: contextId,
+          prompt: "User: Say hello in one short sentence.\nAssistant:",
+          max_tokens: 48,
+          temperature: 0.7,
+          top_p: 0.9,
+          top_k: 40,
+          stop: ["<|im_end|>", "<|endoftext|>", "\nUser:"]
+        },
+        12e4
+      );
+      r.inferMs = Math.round(now() - gt);
+      const outTokens = Number(res.outputTokens ?? res.tokens ?? 0);
+      const text = String(res.text ?? "");
+      const tps = r.inferMs > 0 ? outTokens * 1e3 / r.inferMs : 0;
+      r.throughput = {
+        kind: "tokens_per_sec",
+        value: Math.round(tps * 10) / 10
+      };
+      r.detail = {
+        outputTokens: outTokens,
+        sample: text.slice(0, 120),
+        mtp: res.specAccepted ?? res.mtpAccepted ?? null
+      };
+      r.ok = outTokens > 0 && text.trim().length > 0;
+      if (!r.ok) r.error = "text model returned empty output";
+    } catch (error) {
+      r.error = error instanceof Error ? error.message : String(error);
+      let availAtFail = null;
+      try {
+        availAtFail = availGb(await deps.hardwareInfo());
+      } catch {
+      }
+      r.loadDetail = r.loadDetail ?? {
+        availPreLoadGb: availPreLoad,
+        availAtFailureGb: availAtFail,
+        usedBeforeFailureGb: availPreLoad !== null && availAtFail !== null ? Math.round((availPreLoad - availAtFail) * 1e3) / 1e3 : null
+      };
+    }
+    await trackMem();
+    models.push(r);
+  }
+  let ttsWav = null;
+  {
+    const r = { model: "tts", ok: false };
+    try {
+      const st = now();
+      ttsWav = await deps.synthesizeTts(GRIND_PHRASE);
+      r.inferMs = Math.round(now() - st);
+      const { pcm, sampleRate } = decodeWavToPcm(ttsWav.bytes);
+      const audioSec = pcm.length / sampleRate;
+      const rtf = audioSec > 0 ? r.inferMs / 1e3 / audioSec : 0;
+      r.throughput = { kind: "rtf", value: Math.round(rtf * 1e3) / 1e3 };
+      r.detail = {
+        audioSec: Math.round(audioSec * 100) / 100,
+        samples: pcm.length,
+        sampleRate
+      };
+      r.ok = pcm.length > sampleRate * 0.3 && audioSec > 0.3;
+      if (!r.ok) r.error = "TTS produced too little audio";
+    } catch (error) {
+      r.error = error instanceof Error ? error.message : String(error);
+    }
+    await trackMem();
+    models.push(r);
+  }
+  {
+    const r = { model: "asr", ok: false };
+    try {
+      if (!ttsWav) throw new Error("no TTS audio to transcribe (TTS failed)");
+      const { pcm, sampleRate } = decodeWavToPcm(ttsWav.bytes);
+      const pcm16k = resamplePcm(pcm, sampleRate, 16e3);
+      const at = now();
+      const transcript = await deps.transcribeAsr(pcm16k, 16e3);
+      r.inferMs = Math.round(now() - at);
+      const wer = wordErrorRate(GRIND_PHRASE, transcript);
+      r.throughput = { kind: "wer", value: Math.round(wer * 1e3) / 1e3 };
+      r.detail = { reference: GRIND_PHRASE, hypothesis: transcript, wer };
+      r.ok = transcript.trim().length > 0 && wer <= 0.5;
+      if (!r.ok)
+        r.error = `ASR round-trip WER too high (${wer.toFixed(2)}) or empty`;
+    } catch (error) {
+      r.error = error instanceof Error ? error.message : String(error);
+    }
+    await trackMem();
+    models.push(r);
+  }
+  let afterAvailGb = null;
+  try {
+    afterAvailGb = availGb(await deps.hardwareInfo());
+  } catch {
+  }
+  const peakUsedDeltaGb = beforeAvailGb !== null && minAvailGb !== null ? Math.round((beforeAvailGb - minAvailGb) * 1e3) / 1e3 : null;
+  const passed = models.filter((m) => m.ok).length;
+  const finishedAtEpochMs = Date.now();
+  return {
+    startedAtEpochMs,
+    finishedAtEpochMs,
+    totalMs: Math.round(now() - t0),
+    bundleDir: deps.bundleDir,
+    device,
+    memory: { beforeAvailGb, afterAvailGb, peakUsedDeltaGb },
+    models,
+    overall: {
+      allPassed: passed === models.length,
+      passed,
+      failed: models.length - passed
+    }
+  };
+}
+
+// src/ios/bridge.ts
+async function loadAgentModule() {
+  const [{ bootElizaRuntime }, { dispatchRoute }] = await Promise.all([
+    import("@elizaos/agent/runtime"),
+    import("@elizaos/agent/api")
+  ]);
+  return { bootElizaRuntime, dispatchRoute };
+}
+var IOS_NATIVE_LLAMA_PROVIDER = "capacitor-llama";
+var IOS_NATIVE_LLAMA_DEVICE_ID = "ios-native-llama";
+var IOS_NATIVE_LLAMA_PRIORITY = 0;
+var ELIZA_1_HF_REPO = "elizaos/eliza-1";
+var IOS_NATIVE_CATALOG_MODELS = [
+  {
+    id: "eliza-1-2b",
+    displayName: "eliza-1-2B",
+    hfRepo: ELIZA_1_HF_REPO,
+    hfPath: "bundles/2b/text/eliza-1-2b-128k.gguf",
+    ggufFile: "text/eliza-1-2b-128k.gguf",
+    sizeGb: 1.4,
+    minRamGb: 4,
+    params: "2B",
+    bucket: "small",
+    contextLength: 131072
+  }
+];
+var IOS_NATIVE_ASSIGNMENT_SLOTS = /* @__PURE__ */ new Set([
+  "TEXT_SMALL",
+  "TEXT_LARGE",
+  "TEXT_TO_SPEECH",
+  "TRANSCRIPTION"
+]);
+var IOS_NATIVE_NO_THINK_SYSTEM = "Answer with final user-visible content only. Do not include private reasoning, analysis tags, or <think> blocks.";
+var TEXT_GENERATION_MODEL_TYPES = [
+  ModelType.TEXT_NANO,
+  ModelType.TEXT_SMALL,
+  ModelType.TEXT_MEDIUM,
+  ModelType.TEXT_LARGE,
+  ModelType.RESPONSE_HANDLER,
+  ModelType.ACTION_PLANNER,
+  ModelType.TEXT_COMPLETION
+];
+var nativeLlamaState = {
+  contextId: null,
+  modelId: null,
+  modelPath: null,
+  loadedAt: null,
+  status: "idle"
+};
+var nativeDownloadState = /* @__PURE__ */ new Map();
+var pendingHostCalls = /* @__PURE__ */ new Map();
+var hostProtocolWrite = null;
+var nextHostCallId = 1;
+function normalizeHeaderRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const out = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (typeof raw === "string") out[key] = raw;
+    else if (typeof raw === "number" || typeof raw === "boolean") {
+      out[key] = String(raw);
+    }
+  }
+  return out;
+}
+function isSafeLocalPath(path2) {
+  return path2.startsWith("/") && !path2.startsWith("//") && !/^[a-zA-Z][a-zA-Z\d+.-]*:\/\//.test(path2);
+}
+function normalizeMethod(value) {
+  const method = (typeof value === "string" ? value : "GET").trim().toUpperCase();
+  if (!/^[A-Z]{1,16}$/.test(method)) {
+    throw new Error("Unsupported HTTP method");
+  }
+  return method;
+}
+function argvValue(argv, flag) {
+  const index = argv.indexOf(flag);
+  if (index < 0) return null;
+  const value = argv[index + 1];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function setProcessEnv(key, value, overwrite = true) {
+  if (!key || typeof value !== "string" || value.length === 0) return;
+  if (!overwrite && process2.env[key]) return;
+  try {
+    process2.env[key] = value;
+  } catch {
+  }
+}
+function hydrateIosEnvFromArgv(argv = process2.argv) {
+  const rawEnv = argvValue(argv, "--eliza-ios-env-json");
+  if (rawEnv) {
+    try {
+      const parsed = JSON.parse(rawEnv);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        for (const [key, value] of Object.entries(parsed)) {
+          if (typeof value === "string") setProcessEnv(key, value, true);
+        }
+      }
+    } catch (error) {
+      console.error(
+        "[ios-bridge] failed to parse argv env envelope:",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  const appSupportDir = argvValue(argv, "--eliza-ios-app-support-dir") || process2.env.ELIZA_IOS_APP_SUPPORT_DIR || process2.env.ELIZA_HOME || null;
+  const bundlePath = argvValue(argv, "--eliza-ios-agent-bundle") || process2.env.ELIZA_IOS_AGENT_BUNDLE || null;
+  if (appSupportDir) {
+    setProcessEnv("HOME", appSupportDir, true);
+    setProcessEnv("ELIZA_HOME", appSupportDir, true);
+    setProcessEnv("ELIZA_STATE_DIR", appSupportDir, true);
+    setProcessEnv("ELIZA_IOS_APP_SUPPORT_DIR", appSupportDir, true);
+    setProcessEnv("MOBILE_WORKSPACE_ROOT", appSupportDir, true);
+    setProcessEnv(
+      "ELIZA_WORKSPACE_DIR",
+      path.join(appSupportDir, "workspace"),
+      true
+    );
+    setProcessEnv(
+      "PGLITE_DATA_DIR",
+      path.join(appSupportDir, ".elizadb"),
+      true
+    );
+  }
+  if (bundlePath) {
+    setProcessEnv("ELIZA_IOS_AGENT_BUNDLE", bundlePath, true);
+    const assetDir = path.dirname(bundlePath);
+    setProcessEnv("ELIZA_IOS_AGENT_ASSET_DIR", assetDir, true);
+    setProcessEnv("ELIZA_IOS_AGENT_PUBLIC_DIR", path.dirname(assetDir), true);
+  }
+  return { appSupportDir, bundlePath };
+}
+async function startIosBridgeBackend() {
+  const argvEnv = hydrateIosEnvFromArgv();
+  const mobileWorkspaceRoot = process2.env.MOBILE_WORKSPACE_ROOT || argvEnv.appSupportDir || process2.env.ELIZA_WORKSPACE_DIR || process2.env.ELIZA_STATE_DIR || process2.env.ELIZA_HOME || (process2.env.HOME ? `${process2.env.HOME}/Library/Application Support/Eliza/workspace` : "/tmp/eliza-workspace");
+  installMobileFsShim(mobileWorkspaceRoot);
+  globalThis.__ELIZA_DISABLE_DIRECT_RUN = true;
+  process2.env.ELIZA_PLATFORM = process2.env.ELIZA_PLATFORM || "ios";
+  process2.env.ELIZA_MOBILE_PLATFORM = process2.env.ELIZA_MOBILE_PLATFORM || "ios";
+  process2.env.ELIZA_IOS_LOCAL_BACKEND = process2.env.ELIZA_IOS_LOCAL_BACKEND || "1";
+  process2.env.ELIZA_DISABLE_DIRECT_RUN = process2.env.ELIZA_DISABLE_DIRECT_RUN || "1";
+  process2.env.ELIZA_HEADLESS = process2.env.ELIZA_HEADLESS || "1";
+  process2.env.ELIZA_IOS_BRIDGE_TRANSPORT = process2.env.ELIZA_IOS_BRIDGE_TRANSPORT || "bun-host-ipc";
+  process2.env.ELIZA_VAULT_BACKEND = process2.env.ELIZA_VAULT_BACKEND || "file";
+  process2.env.ELIZA_DISABLE_VAULT_PROFILE_RESOLVER = process2.env.ELIZA_DISABLE_VAULT_PROFILE_RESOLVER || "1";
+  process2.env.ELIZA_DISABLE_AGENT_WALLET_BOOTSTRAP = process2.env.ELIZA_DISABLE_AGENT_WALLET_BOOTSTRAP || "1";
+  process2.env.LOG_LEVEL = process2.env.LOG_LEVEL || "error";
+  const { bootElizaRuntime, dispatchRoute } = await loadAgentModule();
+  const runtime = await bootElizaRuntime();
+  installIosNativeLlamaHandlers(runtime);
+  maybeAutoRunModelGrind();
+  return {
+    runtime,
+    dispatchRoute,
+    conversations: /* @__PURE__ */ new Map(),
+    close: async () => {
+      await unloadNativeLlamaModel().catch(() => void 0);
+    }
+  };
+}
+function maybeAutoRunModelGrind() {
+  if (process2.env.ELIZA_IOS_RUN_MODEL_GRIND !== "1") return;
+  void (async () => {
+    const deadline = Date.now() + 12e4;
+    while (hostProtocolWrite == null && Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 500));
+    }
+    if (hostProtocolWrite == null) {
+      console.error("[model-grind] native host never wired; skipping");
+      return;
+    }
+    try {
+      const report = await runModelGrind({
+        callIosHost,
+        ensureTextModelLoaded: (slot) => ensureNativeModelLoaded(slot),
+        synthesizeTts: async (text) => ({
+          bytes: await synthesizeNativeIosLocalTts({ text }),
+          sampleRate: 24e3
+        }),
+        transcribeAsr: (pcm, sampleRate) => transcribeNativeIosLocalAsr({ pcm, sampleRate }),
+        hardwareInfo: () => nativeHardwareInfo(),
+        bundleDir: nativeVoiceBundleDir()
+      });
+      const json = JSON.stringify(report);
+      console.log(`[model-grind] REPORT ${json}`);
+      const supportDir = process2.env.ELIZA_IOS_APP_SUPPORT_DIR?.trim();
+      if (supportDir) {
+        try {
+          writeFileSync2(
+            path.join(supportDir, "model-grind-report.json"),
+            `${JSON.stringify(report, null, 2)}
+`
+          );
+        } catch (error) {
+          console.error(
+            "[model-grind] report write failed:",
+            error instanceof Error ? error.message : error
+          );
+        }
+      }
+    } catch (error) {
+      console.error(
+        "[model-grind] grind failed:",
+        error instanceof Error ? error.message : error
+      );
+    }
+  })();
+}
+function startIosBridgeHost() {
+  const host = {
+    backend: null,
+    bootError: null,
+    backendPromise: null
+  };
+  return host;
+}
+function ensureIosBridgeBackendStarted(host) {
+  if (host.backendPromise) return host.backendPromise;
+  host.backendPromise = startIosBridgeBackend().then(
+    (backend) => {
+      host.backend = backend;
+      return backend;
+    },
+    (error) => {
+      host.bootError = error;
+      throw error;
+    }
+  );
+  host.backendPromise.catch(() => {
+    return void 0;
+  });
+  return host.backendPromise;
+}
+async function awaitIosBridgeBackend(host, timeoutMs, label) {
+  if (host.backend) return host.backend;
+  if (host.bootError) {
+    throw host.bootError instanceof Error ? host.bootError : new Error(String(host.bootError));
+  }
+  const result = await timeoutAfter(
+    ensureIosBridgeBackendStarted(host),
+    timeoutMs,
+    `${label} backend startup`
+  );
+  if (isTimeoutMarker(result)) {
+    throw new Error(`${result.label} timed out after ${result.timeoutMs}ms`);
+  }
+  return result;
+}
+function splitPathAndQuery(rawPath) {
+  const qIndex = rawPath.indexOf("?");
+  if (qIndex < 0) return { pathname: rawPath, query: {} };
+  const pathname = rawPath.slice(0, qIndex);
+  const params = new URLSearchParams(rawPath.slice(qIndex + 1));
+  const query = {};
+  for (const key of params.keys()) {
+    const all = params.getAll(key);
+    query[key] = all.length <= 1 ? all[0] ?? "" : all;
+  }
+  return { pathname, query };
+}
+function payloadBodyAsRaw(payload) {
+  if (typeof payload.bodyBase64 === "string") {
+    return Buffer.from(payload.bodyBase64, "base64");
+  }
+  if (payload.bodyEncoding === "base64" && typeof payload.body === "string") {
+    return Buffer.from(payload.body, "base64");
+  }
+  return payload.body;
+}
+function statusTextForCode(status) {
+  if (status === 200) return "OK";
+  if (status === 201) return "Created";
+  if (status === 204) return "No Content";
+  if (status === 400) return "Bad Request";
+  if (status === 401) return "Unauthorized";
+  if (status === 403) return "Forbidden";
+  if (status === 404) return "Not Found";
+  if (status === 504) return "Gateway Timeout";
+  if (status === 500) return "Internal Server Error";
+  return "";
+}
+function bridgeStatus(values = {}) {
+  return {
+    ready: values.ready ?? true,
+    engine: "bun",
+    transport: "bun-host-ipc",
+    bridgeVersion: "bun-ios:3",
+    ...values.phase ? { phase: values.phase } : {},
+    ...values.error ? { error: values.error } : {}
+  };
+}
+function timeoutResponse(label, timeoutMs) {
+  const body = JSON.stringify({
+    error: `${label} timed out after ${timeoutMs}ms`,
+    code: "timeout",
+    timeoutMs
+  });
+  return {
+    status: 504,
+    statusText: statusTextForCode(504),
+    headers: { "content-type": "application/json; charset=utf-8" },
+    body,
+    bodyBase64: Buffer.from(body, "utf8").toString("base64"),
+    bodyEncoding: "utf-8"
+  };
+}
+function timeoutAfter(promise, timeoutMs, label) {
+  if (!timeoutMs || timeoutMs <= 0) return promise;
+  const jsTimeoutMs = Math.max(100, timeoutMs - 500);
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      resolve({ __timeout: true, timeoutMs: jsTimeoutMs, label });
+    }, jsTimeoutMs);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+function bridgeTimeoutMs(value) {
+  return typeof value === "number" && value > 0 ? Math.min(value, 30 * 6e4) : void 0;
+}
+function isTimeoutMarker(value) {
+  return Boolean(
+    value && typeof value === "object" && "__timeout" in value && value.__timeout === true
+  );
+}
+async function fetchBackend(backend, payload) {
+  const rawPath = typeof payload.path === "string" ? payload.path.trim() : "";
+  if (!rawPath || !isSafeLocalPath(rawPath)) {
+    throw new Error(
+      "iOS bridge http_request requires a path that starts with / and is not an absolute URL"
+    );
+  }
+  const method = normalizeMethod(payload.method);
+  const headers = normalizeHeaderRecord(payload.headers);
+  const timeoutMs = bridgeTimeoutMs(payload.timeoutMs);
+  const { pathname, query } = splitPathAndQuery(rawPath);
+  const direct = await timeoutAfter(
+    handleDirectCoreRoute(backend, method, rawPath, payload),
+    timeoutMs,
+    `${method} ${pathname}`
+  );
+  if (isTimeoutMarker(direct)) {
+    return timeoutResponse(direct.label, direct.timeoutMs);
+  }
+  if (direct) return direct;
+  const result = await timeoutAfter(
+    backend.dispatchRoute({
+      runtime: backend.runtime,
+      method,
+      path: pathname,
+      headers,
+      query,
+      body: payloadBodyAsRaw(payload),
+      inProcess: true,
+      isAuthorized: () => true
+    }),
+    timeoutMs,
+    `${method} ${pathname}`
+  );
+  if (isTimeoutMarker(result)) {
+    return timeoutResponse(result.label, result.timeoutMs);
+  }
+  if (result) {
+    const responseHeaders = result.headers ?? {};
+    let bodyBytes;
+    if (result.body == null) {
+      bodyBytes = Buffer.alloc(0);
+    } else if (typeof result.body === "string") {
+      bodyBytes = Buffer.from(result.body, "utf8");
+    } else if (Buffer.isBuffer(result.body)) {
+      bodyBytes = result.body;
+    } else if (result.body instanceof Uint8Array) {
+      bodyBytes = Buffer.from(result.body);
+    } else {
+      bodyBytes = Buffer.from(JSON.stringify(result.body), "utf8");
+      if (!Object.keys(responseHeaders).some(
+        (k) => k.toLowerCase() === "content-type"
+      )) {
+        responseHeaders["content-type"] = "application/json; charset=utf-8";
+      }
+    }
+    return {
+      status: result.status,
+      statusText: statusTextForCode(result.status),
+      headers: responseHeaders,
+      body: bodyBytes.toString("utf8"),
+      bodyBase64: bodyBytes.toString("base64"),
+      bodyEncoding: "utf-8"
+    };
+  }
+  return jsonResponse(404, {
+    error: `No iOS local route for ${method} ${pathname}`,
+    code: "not_found"
+  });
+}
+function parseJsonBody(body) {
+  try {
+    return JSON.parse(body);
+  } catch {
+    return null;
+  }
+}
+function sanitizeLocalInferenceSpeechText(input) {
+  let text = input.normalize("NFKC");
+  text = text.replace(/<think\b[^>]*>[\s\S]*?(?:<\/think>|$)/gi, " ");
+  text = text.replace(
+    /<(analysis|reasoning|tool_calls?|tools?)\b[^>]*>[\s\S]*?(?:<\/\1>|$)/gi,
+    " "
+  );
+  text = text.replace(/```[\s\S]*?```/g, " ");
+  text = text.replace(/`([^`]+)`/g, "$1");
+  text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+  text = text.replace(/<[^>\n]+>/g, " ");
+  text = text.replace(/\bhttps?:\/\/\S+/gi, " ");
+  return text.replace(/\s+/g, " ").trim();
+}
+function normalizeAudioBytes(value) {
+  if (value instanceof Uint8Array) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
+  }
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  throw new Error("TEXT_TO_SPEECH returned a non-binary payload");
+}
+function sniffAudioContentType(bytes) {
+  if (bytes.length >= 12 && bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 65 && bytes[10] === 86 && bytes[11] === 69) {
+    return "audio/wav";
+  }
+  if (bytes.length >= 3 && bytes[0] === 73 && bytes[1] === 68 && bytes[2] === 51) {
+    return "audio/mpeg";
+  }
+  if (bytes.length >= 2 && bytes[0] === 255 && (bytes[1] & 224) === 224) {
+    return "audio/mpeg";
+  }
+  return "application/octet-stream";
+}
+function optionalString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function optionalPositiveNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function jsonResponse(status, body) {
+  const text = JSON.stringify(body);
+  return {
+    status,
+    statusText: statusTextForCode(status),
+    headers: { "content-type": "application/json; charset=utf-8" },
+    body: text,
+    bodyBase64: Buffer.from(text, "utf8").toString("base64"),
+    bodyEncoding: "utf-8"
+  };
+}
+function bytesResponse(status, bytes, headers) {
+  const body = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return {
+    status,
+    statusText: statusTextForCode(status),
+    headers,
+    body: body.toString("utf8"),
+    bodyBase64: body.toString("base64"),
+    bodyEncoding: "utf-8"
+  };
+}
+function runtimeAgentName(runtime) {
+  const character = runtime.character;
+  return typeof character?.name === "string" && character.name.trim() ? character.name.trim() : "Eliza";
+}
+function parseRequestBody(payload) {
+  const raw = payloadBodyAsRaw(payload);
+  if (!raw) return {};
+  if (Buffer.isBuffer(raw)) {
+    const parsed = parseJsonBody(raw.toString("utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  }
+  if (typeof raw === "string") {
+    const parsed = parseJsonBody(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  }
+  return typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+}
+function createIosConversation(backend, input = {}) {
+  const id = crypto.randomUUID();
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const metadata = input.metadata && typeof input.metadata === "object" && !Array.isArray(input.metadata) ? input.metadata : void 0;
+  const conversation = {
+    id,
+    title: typeof input.title === "string" && input.title.trim() ? input.title.trim() : "New Chat",
+    roomId: stringToUuid(`ios-conv-${id}`),
+    createdAt: now2,
+    updatedAt: now2,
+    ...metadata ? { metadata } : {}
+  };
+  backend.conversations.set(id, conversation);
+  return conversation;
+}
+function installHostCallProtocol(write2) {
+  hostProtocolWrite = write2;
+}
+function tryHandleHostResultLine(line) {
+  if (!line.includes('"host_result"')) return false;
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return false;
+  }
+  if (parsed.type !== "host_result" || typeof parsed.id !== "string") {
+    return false;
+  }
+  const pending = pendingHostCalls.get(parsed.id);
+  if (!pending) return true;
+  pendingHostCalls.delete(parsed.id);
+  clearTimeout(pending.timeout);
+  const envelope = parsed.envelope && typeof parsed.envelope === "object" ? parsed.envelope : parsed;
+  if (envelope.ok === false) {
+    pending.reject(
+      new Error(
+        typeof envelope.error === "string" ? envelope.error : "Native host call failed"
+      )
+    );
+    return true;
+  }
+  pending.resolve(envelope.result);
+  return true;
+}
+function callIosHost(method, payload, timeoutMs = 12e4) {
+  const writeHostMessage = hostProtocolWrite;
+  if (!writeHostMessage) {
+    return Promise.reject(
+      new Error("iOS native host-call protocol is not installed")
+    );
+  }
+  const id = `host-${nextHostCallId++}`;
+  const boundedTimeout = Math.max(1e3, Math.min(timeoutMs, 30 * 6e4));
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      pendingHostCalls.delete(id);
+      reject(
+        new Error(
+          `Native iOS host call ${method} timed out after ${boundedTimeout}ms`
+        )
+      );
+    }, boundedTimeout);
+    pendingHostCalls.set(id, { resolve, reject, timeout });
+    writeHostMessage({
+      type: "host_call",
+      id,
+      method,
+      payload,
+      timeoutMs: boundedTimeout
+    });
+  });
+}
+function resolveMobileStateDir() {
+  const explicit = process2.env.ELIZA_STATE_DIR || process2.env.ELIZA_STATE_DIR || process2.env.ELIZA_HOME;
+  if (explicit?.trim()) return explicit.trim();
+  if (process2.env.HOME?.trim()) {
+    return path.join(process2.env.HOME.trim(), ".eliza");
+  }
+  return "/tmp/eliza";
+}
+function localInferenceRootPath() {
+  return path.join(resolveMobileStateDir(), "local-inference");
+}
+function localInferenceRegistryPath() {
+  return path.join(localInferenceRootPath(), "registry.json");
+}
+function localInferenceAssignmentsPath() {
+  return path.join(localInferenceRootPath(), "assignments.json");
+}
+function localInferenceRoutingPath() {
+  return path.join(localInferenceRootPath(), "routing.json");
+}
+function localInferenceModelsPath() {
+  return path.join(localInferenceRootPath(), "models");
+}
+function bundledLocalInferenceModelsPath() {
+  const assetDir = process2.env.ELIZA_IOS_AGENT_ASSET_DIR?.trim();
+  if (!assetDir) return null;
+  return path.join(assetDir, "models");
+}
+function localInferenceDownloadsPath() {
+  return path.join(localInferenceRootPath(), "downloads");
+}
+function readJsonObjectFile(filePath) {
+  try {
+    const parsed = JSON.parse(readFileSync2(filePath, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeJsonObjectFile(filePath, value) {
+  mkdirSync2(path.dirname(filePath), { recursive: true });
+  writeFileSync2(filePath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function iosNativeCatalogById(modelId) {
+  return IOS_NATIVE_CATALOG_MODELS.find((entry) => entry.id === modelId) ?? null;
+}
+function iosNativeCatalogByFile(filePath) {
+  const normalized = filePath.replaceAll("\\", "/").toLowerCase();
+  return IOS_NATIVE_CATALOG_MODELS.find((entry) => {
+    const target = entry.ggufFile.toLowerCase();
+    return normalized.endsWith(`/${target}`) || path.basename(normalized) === path.basename(target);
+  }) ?? null;
+}
+function nativeCatalogModelPayload(model) {
+  return {
+    id: model.id,
+    displayName: model.displayName,
+    hfRepo: model.hfRepo,
+    ggufFile: model.ggufFile,
+    params: model.params,
+    quant: "Q8_0",
+    sizeGb: model.sizeGb,
+    minRamGb: model.minRamGb,
+    category: "chat",
+    bucket: model.bucket,
+    blurb: "Eliza-1 on-device GGUF bundle for iPhone local inference.",
+    contextLength: model.contextLength,
+    gpuLayers: "auto",
+    publishStatus: "published",
+    sourceModel: {
+      finetuned: false,
+      components: {
+        text: { repo: model.hfRepo, file: model.hfPath }
+      }
+    }
+  };
+}
+function modelDownloadUrl(model) {
+  const encodedPath = model.hfPath.split("/").map((part) => encodeURIComponent(part)).join("/");
+  return `https://huggingface.co/${model.hfRepo}/resolve/main/${encodedPath}`;
+}
+function nativeModelTargetPath(model) {
+  return path.join(localInferenceModelsPath(), model.ggufFile);
+}
+function installedModelForCatalogEntry(model, filePath, sizeBytes, installedAt, source) {
+  return {
+    id: model.id,
+    displayName: model.displayName,
+    path: filePath,
+    sizeBytes,
+    installedAt,
+    lastUsedAt: null,
+    source,
+    hfRepo: model.hfRepo,
+    bundleVerifiedAt: installedAt
+  };
+}
+function upsertInstalledModel(model) {
+  const existing = readInstalledModels().filter(
+    (entry) => entry.id !== model.id && entry.path !== model.path
+  );
+  writeJsonObjectFile(localInferenceRegistryPath(), {
+    version: 1,
+    models: [...existing, model],
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function positiveInteger(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return Math.floor(value);
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed) && parsed > 0) return Math.floor(parsed);
+  }
+  return null;
+}
+function readAssignments() {
+  const parsed = readJsonObjectFile(localInferenceAssignmentsPath());
+  const raw = parsed.assignments;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+  const out = {};
+  for (const [slot, modelId] of Object.entries(raw)) {
+    if (typeof modelId === "string" && modelId.trim()) {
+      out[slot] = modelId.trim();
+    }
+  }
+  return out;
+}
+function writeAssignments(assignments) {
+  writeJsonObjectFile(localInferenceAssignmentsPath(), {
+    version: 1,
+    assignments,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function scanGgufFiles(root) {
+  const models = [];
+  const visit = (dir, depth) => {
+    if (depth > 5 || models.length >= 200) return;
+    let entries = [];
+    try {
+      entries = readdirSync2(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry);
+      let stats;
+      try {
+        stats = statSync2(fullPath);
+      } catch {
+        continue;
+      }
+      if (stats.isDirectory()) {
+        visit(fullPath, depth + 1);
+      } else if (stats.isFile() && entry.toLowerCase().endsWith(".gguf")) {
+        const catalogModel = iosNativeCatalogByFile(fullPath);
+        if (catalogModel) {
+          models.push(
+            installedModelForCatalogEntry(
+              catalogModel,
+              fullPath,
+              stats.size,
+              new Date(stats.mtimeMs).toISOString(),
+              "ios-bundled"
+            )
+          );
+        } else {
+          const id = path.basename(entry, path.extname(entry));
+          models.push({
+            id,
+            displayName: id,
+            path: fullPath,
+            sizeBytes: stats.size,
+            installedAt: new Date(stats.mtimeMs).toISOString(),
+            lastUsedAt: null,
+            source: "external-scan"
+          });
+        }
+      }
+    }
+  };
+  visit(root, 0);
+  return models;
+}
+function normalizeInstalledModelPath(rawPath) {
+  const trimmed = rawPath.trim();
+  if (!trimmed || trimmed.includes("\0")) return null;
+  const currentRoot = localInferenceRootPath();
+  const candidates = /* @__PURE__ */ new Set([
+    trimmed,
+    trimmed.replace(/^\/private\/var\//, "/var/")
+  ]);
+  const marker = "/local-inference/";
+  const markerIndex = trimmed.indexOf(marker);
+  if (markerIndex >= 0) {
+    const relativePath = trimmed.slice(markerIndex + marker.length);
+    if (relativePath && !relativePath.startsWith("/") && !relativePath.split(/[\\/]+/).includes("..")) {
+      candidates.add(path.join(currentRoot, relativePath));
+    }
+  }
+  for (const candidate of candidates) {
+    try {
+      if (existsSync2(candidate)) return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function readInstalledModels() {
+  const parsed = readJsonObjectFile(localInferenceRegistryPath());
+  const rawModels = Array.isArray(parsed.models) ? parsed.models : [];
+  const fromRegistry = rawModels.map((entry) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      return null;
+    }
+    const record = entry;
+    if (typeof record.id !== "string" || typeof record.path !== "string") {
+      return null;
+    }
+    const modelPath = normalizeInstalledModelPath(record.path);
+    if (!modelPath) return null;
+    return {
+      id: record.id,
+      displayName: typeof record.displayName === "string" ? record.displayName : record.id,
+      path: modelPath,
+      sizeBytes: positiveInteger(record.sizeBytes) ?? 0,
+      installedAt: typeof record.installedAt === "string" ? record.installedAt : (/* @__PURE__ */ new Date()).toISOString(),
+      lastUsedAt: typeof record.lastUsedAt === "string" ? record.lastUsedAt : null,
+      source: typeof record.source === "string" ? record.source : void 0,
+      hfRepo: typeof record.hfRepo === "string" ? record.hfRepo : void 0,
+      bundleVerifiedAt: typeof record.bundleVerifiedAt === "string" ? record.bundleVerifiedAt : void 0,
+      dimensions: positiveInteger(record.dimensions) ?? void 0,
+      embeddingDimension: positiveInteger(record.embeddingDimension) ?? void 0,
+      embeddingDimensions: positiveInteger(record.embeddingDimensions) ?? void 0
+    };
+  }).filter((entry) => Boolean(entry));
+  const bundledModelsPath = bundledLocalInferenceModelsPath();
+  const scanned = [
+    ...bundledModelsPath ? scanGgufFiles(bundledModelsPath) : [],
+    ...scanGgufFiles(localInferenceModelsPath())
+  ];
+  const byId = /* @__PURE__ */ new Map();
+  for (const model of [...scanned, ...fromRegistry]) {
+    byId.set(model.id, model);
+  }
+  return [...byId.values()];
+}
+function isEmbeddingModel(model) {
+  const lowered = model.id.toLowerCase();
+  return lowered.includes("embed") || lowered.includes("bge-") || lowered.includes("nomic") || lowered.includes("gte-") || lowered.includes("e5-");
+}
+function resolveAssignedModel(slot) {
+  const installed = readInstalledModels().filter(
+    (model) => !isEmbeddingModel(model)
+  );
+  const assignments = readAssignments();
+  const assigned = assignments[slot];
+  if (assigned) {
+    const model = installed.find((entry) => entry.id === assigned);
+    if (model) return model;
+  }
+  if (nativeLlamaState.modelPath) {
+    const current = installed.find(
+      (entry) => entry.path === nativeLlamaState.modelPath
+    );
+    if (current) return current;
+  }
+  return installed.sort((left, right) => {
+    const leftUsed = left.lastUsedAt ? Date.parse(left.lastUsedAt) : 0;
+    const rightUsed = right.lastUsedAt ? Date.parse(right.lastUsedAt) : 0;
+    if (rightUsed !== leftUsed) return rightUsed - leftUsed;
+    return (right.sizeBytes ?? 0) - (left.sizeBytes ?? 0);
+  })[0] ?? null;
+}
+function nativeLlamaContextSize() {
+  return positiveInteger(process2.env.ELIZA_IOS_LLAMA_CONTEXT_SIZE) ?? positiveInteger(process2.env.ELIZA_IOS_LLAMA_CONTEXT_SIZE) ?? positiveInteger(process2.env.ELIZA_LOCAL_CONTEXT_SIZE) ?? 4096;
+}
+function isMetalLoadError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /metal/i.test(message) || /MTLLibraryErrorDomain/.test(message) || /ggml_metal/i.test(message);
+}
+async function shouldUseNativeLlamaGpu() {
+  const explicit = process2.env.ELIZA_IOS_LLAMA_USE_GPU;
+  if (explicit === "1" || explicit?.toLowerCase() === "true") return true;
+  if (explicit === "0" || explicit?.toLowerCase() === "false") return false;
+  const hardware = await nativeHardwareInfo();
+  return hardware.metal_supported === true && hardware.is_simulator !== true;
+}
+async function loadNativeLlamaModel(model, useGpu) {
+  const result = await callIosHost(
+    "llama_load_model",
+    {
+      path: model.path,
+      modelId: model.id,
+      context_size: nativeLlamaContextSize(),
+      use_gpu: useGpu
+    },
+    10 * 6e4
+  );
+  return result && typeof result === "object" && !Array.isArray(result) ? result : {};
+}
+async function ensureNativeModelLoaded(slot) {
+  const model = resolveAssignedModel(slot);
+  if (!model) {
+    throw new Error(
+      `[ios-native-llama] No local GGUF model is installed under ${path.join(
+        localInferenceRootPath(),
+        "models"
+      )}. Download or install a model before using local generation.`
+    );
+  }
+  if (nativeLlamaState.contextId != null && nativeLlamaState.modelPath === model.path && nativeLlamaState.status === "ready") {
+    return nativeLlamaState;
+  }
+  await unloadNativeLlamaModel();
+  nativeLlamaState.status = "loading";
+  nativeLlamaState.modelId = model.id;
+  nativeLlamaState.modelPath = model.path;
+  nativeLlamaState.loadedAt = null;
+  delete nativeLlamaState.error;
+  try {
+    let requestedGpu = await shouldUseNativeLlamaGpu();
+    let record;
+    try {
+      record = await loadNativeLlamaModel(model, requestedGpu);
+    } catch (error) {
+      if (!requestedGpu || !isMetalLoadError(error)) throw error;
+      requestedGpu = false;
+      record = await loadNativeLlamaModel(model, false);
+    }
+    const contextId = positiveInteger(record.context_id) ?? positiveInteger(record.contextId);
+    if (contextId == null) {
+      throw new Error("Native llama load returned no context_id");
+    }
+    nativeLlamaState.contextId = contextId;
+    nativeLlamaState.loadedAt = (/* @__PURE__ */ new Date()).toISOString();
+    nativeLlamaState.status = "ready";
+    return nativeLlamaState;
+  } catch (error) {
+    nativeLlamaState.contextId = null;
+    nativeLlamaState.loadedAt = null;
+    nativeLlamaState.status = "error";
+    nativeLlamaState.error = error instanceof Error ? error.message : String(error);
+    throw error;
+  }
+}
+async function unloadNativeLlamaModel() {
+  const contextId = nativeLlamaState.contextId;
+  nativeLlamaState.contextId = null;
+  nativeLlamaState.loadedAt = null;
+  nativeLlamaState.status = "idle";
+  if (contextId != null) {
+    await callIosHost("llama_free", { context_id: contextId }, 3e4).catch(
+      () => void 0
+    );
+  }
+  nativeLlamaState.modelId = null;
+  nativeLlamaState.modelPath = null;
+  delete nativeLlamaState.error;
+}
+function flattenChatParamsForPrompt(params) {
+  if (typeof params.prompt === "string" && params.prompt.length > 0) {
+    return renderChatMlPrompt(IOS_NATIVE_NO_THINK_SYSTEM, [
+      { role: "user", content: params.prompt }
+    ]);
+  }
+  const systemBlocks = [IOS_NATIVE_NO_THINK_SYSTEM];
+  if (typeof params.system === "string" && params.system) {
+    systemBlocks.push(params.system);
+  }
+  const chatMessages = [];
+  const messages = params.messages ?? [];
+  for (const message of messages) {
+    const role = message.role === "system" || message.role === "assistant" || message.role === "tool" ? message.role : "user";
+    if (typeof message.content === "string") {
+      if (message.content) {
+        if (role === "system") systemBlocks.push(message.content);
+        else chatMessages.push({ role, content: message.content });
+      }
+      continue;
+    }
+    if (Array.isArray(message.content)) {
+      const text = message.content.map(
+        (part) => part && typeof part === "object" && "text" in part ? String(part.text ?? "") : ""
+      ).filter(Boolean).join("\n");
+      if (text) {
+        if (role === "system") systemBlocks.push(text);
+        else chatMessages.push({ role, content: text });
+      }
+    }
+  }
+  return renderChatMlPrompt(systemBlocks.join("\n\n"), chatMessages);
+}
+function renderChatMlPrompt(system, messages) {
+  const blocks = [`<|im_start|>system
+${system.trim()}
+<|im_end|>`];
+  for (const message of messages) {
+    const role = message.role === "assistant" || message.role === "tool" ? message.role : "user";
+    const content = message.content.trim();
+    if (content) blocks.push(`<|im_start|>${role}
+${content}
+<|im_end|>`);
+  }
+  blocks.push("<|im_start|>assistant\n<think>\n\n</think>\n\n");
+  return blocks.join("\n");
+}
+function stripReasoningBlocks(raw) {
+  return raw.replace(/<think\b[^>]*>[\s\S]*?<\/think>/gi, "").replace(/^[\s\S]*?<\/think>/i, "").replace(/<think\b[^>]*>[\s\S]*$/gi, "").replace(/\/?\bno_think\b/gi, "").trim();
+}
+function cleanIosNativeConversationReply(raw) {
+  const withoutTokens = stripReasoningBlocks(raw).split("<|im_end|>")[0].split("<|im_start|>")[0].replace(/^\s*(assistant|eliza)\s*:\s*/i, "").trim();
+  const compact = withoutTokens.replace(/\s+/g, " ").trim();
+  if (!compact) return "";
+  const firstSentence = compact.match(/^(.{12,280}?[.!?])(?:\s|$)/u)?.[1];
+  return (firstSentence ?? compact).trim();
+}
+async function maybeGenerateIosNativeConversationReply(runtime, prompt) {
+  const installed = readInstalledModels().filter(
+    (model) => !isEmbeddingModel(model)
+  );
+  if (installed.length === 0) return null;
+  const startedAt = Date.now();
+  const raw = await runtime.useModel(
+    ModelType.TEXT_SMALL,
+    {
+      messages: [
+        {
+          role: "system",
+          content: "Eliza-1 is running locally on this iPhone. Reply with one natural sentence under 10 words."
+        },
+        { role: "user", content: prompt }
+      ],
+      maxTokens: 32,
+      temperature: 0,
+      stopSequences: ["<|im_end|>", "<|im_start|>"]
+    },
+    IOS_NATIVE_LLAMA_PROVIDER
+  );
+  const text = cleanIosNativeConversationReply(raw);
+  if (!text) {
+    throw new Error("Native llama returned an empty response");
+  }
+  return {
+    text,
+    reply: text,
+    localInference: {
+      provider: IOS_NATIVE_LLAMA_PROVIDER,
+      modelId: nativeLlamaState.modelId ?? installed[0]?.id ?? null,
+      mode: "ios_native_conversation",
+      latencyMs: Date.now() - startedAt
+    }
+  };
+}
+function isStructuredGenerationSlot(slot) {
+  return slot === ModelType.RESPONSE_HANDLER || slot === ModelType.ACTION_PLANNER || slot === ModelType.TEXT_COMPLETION;
+}
+function mergeStopSequences(values) {
+  const requested = Array.isArray(values) ? values.filter((value) => typeof value === "string") : [];
+  return Array.from(/* @__PURE__ */ new Set([...requested, "<|im_end|>", "<|endoftext|>"]));
+}
+function makeIosNativeGenerateHandler(slot) {
+  return async (_runtime, params) => {
+    const state = await ensureNativeModelLoaded(slot);
+    if (state.contextId == null) {
+      throw new Error(
+        "[ios-native-llama] model load did not produce a context"
+      );
+    }
+    const prompt = flattenChatParamsForPrompt(params);
+    const structuredSlot = isStructuredGenerationSlot(slot);
+    const requestedMaxTokens = positiveInteger(params.maxTokens) ?? 256;
+    const maxTokens = Math.min(requestedMaxTokens, structuredSlot ? 256 : 128);
+    const result = await callIosHost(
+      "llama_generate",
+      {
+        context_id: state.contextId,
+        prompt,
+        max_tokens: maxTokens,
+        temperature: typeof params.temperature === "number" ? params.temperature : structuredSlot ? 0.2 : 0.4,
+        top_p: typeof params.topP === "number" ? params.topP : 0.95,
+        top_k: positiveInteger(params.topK) ?? 40,
+        stop: mergeStopSequences(params.stopSequences)
+      },
+      Math.max(12e4, maxTokens * 2e3)
+    );
+    const record = result && typeof result === "object" && !Array.isArray(result) ? result : {};
+    const text = typeof record.text === "string" ? record.text : String(result ?? "");
+    const cleanedText = stripReasoningBlocks(text);
+    if (params.onStreamChunk && cleanedText) {
+      await params.onStreamChunk(cleanedText, crypto.randomUUID(), cleanedText);
+    }
+    return cleanedText;
+  };
+}
+function installIosNativeLlamaHandlers(runtime) {
+  const flagged = runtime;
+  if (flagged.__iosNativeLlamaHandlersInstalled) return;
+  const runtimeWithRegistration = runtime;
+  if (typeof runtimeWithRegistration.registerModel !== "function") return;
+  for (const modelType of TEXT_GENERATION_MODEL_TYPES) {
+    runtimeWithRegistration.registerModel(
+      modelType,
+      makeIosNativeGenerateHandler(modelType),
+      IOS_NATIVE_LLAMA_PROVIDER,
+      IOS_NATIVE_LLAMA_PRIORITY
+    );
+  }
+  flagged.__iosNativeLlamaHandlersInstalled = true;
+}
+async function nativeHardwareInfo() {
+  try {
+    const result = await callIosHost("llama_hardware_info", {}, 1e4);
+    return result && typeof result === "object" && !Array.isArray(result) ? result : {};
+  } catch (error) {
+    return {
+      backend: "unknown",
+      total_ram_gb: 0,
+      available_ram_gb: 0,
+      cpu_cores: 0,
+      is_simulator: process2.env.SIMULATOR_DEVICE_NAME ? true : void 0,
+      metal_supported: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function nativeLlamaDeviceStatus() {
+  const hardware = await nativeHardwareInfo();
+  const totalRamGb = Number(hardware.total_ram_gb ?? 0);
+  const cpuCores = Number(hardware.cpu_cores ?? 0);
+  const metalSupported = hardware.metal_supported === true;
+  return {
+    enabled: true,
+    connected: true,
+    transport: "bun-host-ipc",
+    devices: [
+      {
+        deviceId: IOS_NATIVE_LLAMA_DEVICE_ID,
+        capabilities: {
+          platform: "ios",
+          deviceModel: hardware.is_simulator === true ? "iOS Simulator" : "iOS Device",
+          totalRamGb,
+          cpuCores,
+          gpu: {
+            backend: "metal",
+            available: metalSupported
+          }
+        },
+        loadedPath: nativeLlamaState.modelPath,
+        connectedSince: nativeLlamaState.loadedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ],
+    primaryDeviceId: IOS_NATIVE_LLAMA_DEVICE_ID,
+    pendingRequests: pendingHostCalls.size,
+    modelPath: nativeLlamaState.modelPath
+  };
+}
+function nativeLlamaActiveSnapshot() {
+  return {
+    modelId: nativeLlamaState.modelId,
+    modelPath: nativeLlamaState.modelPath,
+    loadedAt: nativeLlamaState.loadedAt,
+    status: nativeLlamaState.status,
+    provider: IOS_NATIVE_LLAMA_PROVIDER,
+    transport: "bun-host-ipc",
+    ...nativeLlamaState.error ? { error: nativeLlamaState.error } : {}
+  };
+}
+async function nativeLocalInferenceProviders() {
+  const installed = readInstalledModels();
+  return {
+    providers: [
+      {
+        id: IOS_NATIVE_LLAMA_PROVIDER,
+        label: "Eliza-1 on-device runtime (iOS)",
+        kind: "local",
+        description: "Runs Eliza-1 natively through the full Bun host IPC bridge.",
+        supportedSlots: ["TEXT_SMALL", "TEXT_LARGE"],
+        configureHref: null,
+        enableState: {
+          enabled: true,
+          reason: "Native iOS llama bridge connected"
+        },
+        registeredSlots: ["TEXT_SMALL", "TEXT_LARGE"],
+        transport: "bun-host-ipc"
+      },
+      {
+        id: "eliza-local-inference",
+        label: "Eliza-1 local inference",
+        kind: "local",
+        description: "Eliza-1 bundles installed in this agent state directory.",
+        supportedSlots: ["TEXT_SMALL", "TEXT_LARGE", "TEXT_EMBEDDING"],
+        configureHref: "#local-inference-panel",
+        enableState: {
+          enabled: installed.length > 0,
+          reason: installed.length > 0 ? "Eliza-1 bundle installed" : "No Eliza-1 bundle installed"
+        },
+        registeredSlots: installed.length > 0 ? ["TEXT_SMALL", "TEXT_LARGE"] : []
+      }
+    ]
+  };
+}
+function nativeCatalogModels() {
+  const curated = IOS_NATIVE_CATALOG_MODELS.map(nativeCatalogModelPayload);
+  const curatedIds = new Set(
+    IOS_NATIVE_CATALOG_MODELS.map((model) => model.id)
+  );
+  const installedCustom = readInstalledModels().filter((model) => !isEmbeddingModel(model) && !curatedIds.has(model.id)).map((model) => {
+    const sizeGb = Math.max(0.1, (model.sizeBytes ?? 0) / 1024 ** 3);
+    return {
+      id: model.id,
+      displayName: model.displayName ?? model.id,
+      hfRepo: model.hfRepo ?? "elizaos/eliza-1",
+      ggufFile: path.basename(model.path),
+      params: "2B",
+      quant: "Q8_0",
+      sizeGb,
+      minRamGb: 4,
+      category: "chat",
+      bucket: sizeGb <= 1 ? "small" : "mid",
+      blurb: "Installed Eliza-1 on-device GGUF bundle.",
+      contextLength: 128e3,
+      gpuLayers: "auto",
+      publishStatus: "published"
+    };
+  });
+  return [...curated, ...installedCustom];
+}
+function nativeDownloadJobs() {
+  const jobs = Array.from(nativeDownloadState.values());
+  const trackedModelIds = new Set(jobs.map((job) => job.modelId));
+  for (const model of readInstalledModels().filter(
+    (entry) => !isEmbeddingModel(entry)
+  )) {
+    if (trackedModelIds.has(model.id)) continue;
+    jobs.push(nativeDownloadJobForInstalledModel(model));
+  }
+  return jobs;
+}
+function nativeDownloadStatus(model) {
+  const bytes = model?.sizeBytes ?? 0;
+  return {
+    state: model ? "completed" : "missing",
+    receivedBytes: bytes,
+    totalBytes: bytes,
+    percent: model ? 100 : null,
+    bytesPerSec: 0,
+    etaMs: model ? 0 : null,
+    updatedAt: model?.lastUsedAt ?? model?.installedAt ?? null,
+    errors: []
+  };
+}
+function nativeDownloadJobForInstalledModel(model) {
+  const installedAt = model.installedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const updatedAt = model.lastUsedAt ?? model.bundleVerifiedAt ?? installedAt;
+  const bytes = model.sizeBytes ?? 0;
+  return {
+    jobId: `installed:${model.id}`,
+    modelId: model.id,
+    state: "completed",
+    received: bytes,
+    total: bytes,
+    bytesPerSec: 0,
+    etaMs: 0,
+    startedAt: installedAt,
+    updatedAt
+  };
+}
+function updateNativeDownloadJob(modelId, patch) {
+  const current = nativeDownloadState.get(modelId);
+  if (!current) {
+    throw new Error(`No native download job is registered for ${modelId}`);
+  }
+  const next = {
+    ...current,
+    ...patch,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  nativeDownloadState.set(modelId, next);
+  return next;
+}
+function writeDownloadChunk(writer, chunk) {
+  return new Promise((resolve, reject) => {
+    writer.write(Buffer.from(chunk), (error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+function closeDownloadWriter(writer) {
+  return new Promise((resolve, reject) => {
+    const onError = (error) => {
+      writer.off("error", onError);
+      reject(error);
+    };
+    writer.once("error", onError);
+    writer.end(() => {
+      writer.off("error", onError);
+      resolve();
+    });
+  });
+}
+async function runNativeModelDownload(model) {
+  const startedMs = Date.now();
+  const totalEstimate = Math.round(model.sizeGb * 1024 ** 3);
+  updateNativeDownloadJob(model.id, {
+    state: "downloading",
+    total: totalEstimate
+  });
+  mkdirSync2(path.dirname(nativeModelTargetPath(model)), { recursive: true });
+  mkdirSync2(localInferenceDownloadsPath(), { recursive: true });
+  const partialPath = path.join(
+    localInferenceDownloadsPath(),
+    `${model.id}.part`
+  );
+  const response = await fetch(modelDownloadUrl(model), { redirect: "follow" });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to download ${model.id}: HTTP ${response.status} ${response.statusText}`
+    );
+  }
+  if (!response.body) {
+    throw new Error(`Failed to download ${model.id}: response body is empty`);
+  }
+  const contentLength = positiveInteger(response.headers.get("content-length")) ?? totalEstimate;
+  updateNativeDownloadJob(model.id, { total: contentLength });
+  const writer = createWriteStream2(partialPath);
+  let received = 0;
+  try {
+    const reader = response.body.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      received += value.byteLength;
+      await writeDownloadChunk(writer, value);
+      const elapsedSeconds = Math.max(1, (Date.now() - startedMs) / 1e3);
+      const bytesPerSec = Math.round(received / elapsedSeconds);
+      const remaining = Math.max(0, contentLength - received);
+      updateNativeDownloadJob(model.id, {
+        received,
+        bytesPerSec,
+        etaMs: bytesPerSec > 0 ? Math.round(remaining / bytesPerSec * 1e3) : null
+      });
+    }
+    await closeDownloadWriter(writer);
+    const targetPath = nativeModelTargetPath(model);
+    renameSync2(partialPath, targetPath);
+    const stats = statSync2(targetPath);
+    const installedAt = (/* @__PURE__ */ new Date()).toISOString();
+    upsertInstalledModel(
+      installedModelForCatalogEntry(
+        model,
+        targetPath,
+        stats.size,
+        installedAt,
+        "eliza-download"
+      )
+    );
+    updateNativeDownloadJob(model.id, {
+      state: "completed",
+      received: stats.size,
+      total: stats.size,
+      bytesPerSec: 0,
+      etaMs: 0
+    });
+  } catch (error) {
+    updateNativeDownloadJob(model.id, {
+      state: "failed",
+      error: error instanceof Error ? error.message : String(error)
+    });
+    writer.destroy();
+    rmSync2(partialPath, { force: true });
+    throw error;
+  }
+}
+function startNativeModelDownload(modelId) {
+  const model = iosNativeCatalogById(modelId);
+  if (!model) throw new Error(`Unsupported iOS local model: ${modelId}`);
+  const installed = readInstalledModels().find(
+    (entry) => entry.id === model.id
+  );
+  if (installed) {
+    const job2 = nativeDownloadJobForInstalledModel(installed);
+    nativeDownloadState.set(model.id, job2);
+    return job2;
+  }
+  const existing = nativeDownloadState.get(model.id);
+  if (existing && (existing.state === "queued" || existing.state === "downloading")) {
+    return existing;
+  }
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const job = {
+    jobId: `ios-download:${model.id}:${Date.now()}`,
+    modelId: model.id,
+    state: "queued",
+    received: 0,
+    total: Math.round(model.sizeGb * 1024 ** 3),
+    bytesPerSec: 0,
+    etaMs: null,
+    startedAt: now2,
+    updatedAt: now2
+  };
+  nativeDownloadState.set(model.id, job);
+  void runNativeModelDownload(model).catch(() => {
+  });
+  return job;
+}
+function nativeTextReadiness() {
+  const installed = readInstalledModels().filter(
+    (model) => !isEmbeddingModel(model)
+  );
+  const assignments = readAssignments();
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const slots = {};
+  for (const slot of ["TEXT_SMALL", "TEXT_LARGE"]) {
+    const assignedModelId = assignments[slot] ?? installed[0]?.id ?? null;
+    const model = assignedModelId == null ? null : installed.find((entry) => entry.id === assignedModelId) ?? null;
+    const active = model != null && nativeLlamaState.modelId === model.id && nativeLlamaState.status === "ready";
+    const downloaded = model != null;
+    slots[slot] = {
+      slot,
+      assigned: assignedModelId != null,
+      assignedModelId,
+      displayName: model?.displayName ?? model?.id ?? null,
+      primaryDownloaded: downloaded,
+      downloaded,
+      active,
+      ready: active,
+      state: active ? "active" : downloaded ? "downloaded" : "missing",
+      requiredModelIds: assignedModelId ? [assignedModelId] : [],
+      missingModelIds: downloaded || !assignedModelId ? [] : [assignedModelId],
+      installedBytes: model?.sizeBytes ?? 0,
+      expectedBytes: model?.sizeBytes ?? 0,
+      download: nativeDownloadStatus(model),
+      errors: nativeLlamaState.error ? [nativeLlamaState.error] : []
+    };
+  }
+  return { updatedAt: now2, slots };
+}
+function hasNativeLocalTtsExecutor() {
+  return hostProtocolWrite != null;
+}
+function hasNativeVoiceBundle(bundleDir) {
+  const ttsDir = path.join(bundleDir, "tts");
+  try {
+    const coreml = path.join(ttsDir, "kokoro-coreml", "kokoro_5s.mlmodelc");
+    const voice = path.join(ttsDir, "kokoro-coreml", "voices", "af_heart.json");
+    if (statSync2(coreml).isDirectory() && statSync2(voice).isFile()) return true;
+  } catch {
+  }
+  try {
+    for (const entry of readdirSync2(ttsDir)) {
+      if (/^omnivoice-base-.*\.gguf$/i.test(entry)) return true;
+      if (entry === "kokoro") {
+        try {
+          for (const k of readdirSync2(path.join(ttsDir, "kokoro"))) {
+            if (/\.gguf$/i.test(k) || k === "model_q4.onnx") return true;
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+function nativeVoiceBundleDir() {
+  const modelsRoots = [
+    path.join(localInferenceRootPath(), "models"),
+    bundledLocalInferenceModelsPath()
+  ].filter((root) => Boolean(root));
+  let bundleDir = null;
+  const visit = (dir, depth) => {
+    if (depth > 6 || bundleDir) return;
+    let entries = [];
+    try {
+      entries = readdirSync2(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry);
+      let stats;
+      try {
+        stats = statSync2(fullPath);
+      } catch {
+        continue;
+      }
+      if (stats.isDirectory()) {
+        if (entry.endsWith(".bundle") && hasNativeVoiceBundle(fullPath)) {
+          bundleDir = fullPath;
+          return;
+        }
+        visit(fullPath, depth + 1);
+        if (bundleDir) return;
+      }
+    }
+  };
+  for (const root of modelsRoots) {
+    visit(root, 0);
+    if (bundleDir) return bundleDir;
+  }
+  return null;
+}
+function nativeVoiceReadiness() {
+  const modelsRoots = [
+    path.join(localInferenceRootPath(), "models"),
+    bundledLocalInferenceModelsPath()
+  ].filter((root) => Boolean(root));
+  let installedFiles = 0;
+  let modelId = null;
+  const visit = (dir, depth) => {
+    if (depth > 6 || installedFiles > 0) return;
+    let entries = [];
+    try {
+      entries = readdirSync2(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry);
+      let stats;
+      try {
+        stats = statSync2(fullPath);
+      } catch {
+        continue;
+      }
+      if (stats.isDirectory()) {
+        visit(fullPath, depth + 1);
+        if (installedFiles > 0) return;
+        continue;
+      }
+      const normalized = fullPath.split(path.sep).join("/");
+      if (stats.isFile() && /\/(tts|voice|asr|vad)\//i.test(normalized) && /\.(gguf|bin|json)$/i.test(entry)) {
+        const markerIndex = normalized.indexOf(".bundle/");
+        if (markerIndex >= 0) {
+          const bundlePath = fullPath.slice(0, markerIndex + ".bundle".length);
+          if (hasNativeVoiceBundle(bundlePath)) {
+            installedFiles += 1;
+            const match = normalized.match(/models\/([^/]+\.bundle)\//);
+            modelId = match?.[1]?.replace(/\.bundle$/, "") ?? null;
+            return;
+          }
+        }
+      }
+    }
+  };
+  for (const root of modelsRoots) {
+    visit(root, 0);
+    if (installedFiles > 0) break;
+  }
+  if (installedFiles > 0) {
+    if (!hasNativeLocalTtsExecutor()) {
+      return {
+        status: "unavailable",
+        installedFiles,
+        modelId,
+        message: "Eliza-1 voice assets are installed. This build is missing the iOS local voice playback engine."
+      };
+    }
+    return {
+      status: "assets-ready",
+      installedFiles,
+      modelId,
+      message: "Local voice assets are installed. Voice engine will warm on first playback."
+    };
+  }
+  return {
+    status: "missing",
+    installedFiles: 0,
+    modelId: null,
+    message: "Eliza-1 voice assets are not installed in this iOS build."
+  };
+}
+function routingPreferencesSnapshot() {
+  const parsed = readJsonObjectFile(localInferenceRoutingPath());
+  const preferences = parsed.preferences && typeof parsed.preferences === "object" ? parsed.preferences : { preferredProvider: {}, policy: {} };
+  return {
+    registrations: ["TEXT_SMALL", "TEXT_LARGE"].map((modelType) => ({
+      modelType,
+      provider: IOS_NATIVE_LLAMA_PROVIDER,
+      priority: IOS_NATIVE_LLAMA_PRIORITY,
+      registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+    })),
+    preferences
+  };
+}
+async function nativeHubSnapshot() {
+  const hardware = await nativeHardwareInfo();
+  return {
+    catalog: nativeCatalogModels(),
+    installed: readInstalledModels(),
+    active: nativeLlamaActiveSnapshot(),
+    downloads: nativeDownloadJobs(),
+    device: await nativeLlamaDeviceStatus(),
+    providers: (await nativeLocalInferenceProviders()).providers,
+    hardware: {
+      totalRamGb: Number(hardware.total_ram_gb ?? 0),
+      freeRamGb: Number(hardware.available_ram_gb ?? 0),
+      gpu: {
+        backend: "metal",
+        available: hardware.metal_supported === true
+      },
+      cpuCores: Number(hardware.cpu_cores ?? 0),
+      platform: "ios",
+      arch: hardware.is_simulator === true ? "simulator" : "arm64",
+      appleSilicon: hardware.metal_supported === true,
+      recommendedBucket: "small",
+      source: "ios-native-llama"
+    },
+    assignments: readAssignments(),
+    textReadiness: nativeTextReadiness(),
+    voiceReadiness: nativeVoiceReadiness()
+  };
+}
+async function synthesizeNativeIosLocalTts(request) {
+  const bundleDir = nativeVoiceBundleDir();
+  if (!bundleDir) {
+    throw new Error("No Eliza-1 voice bundle is installed");
+  }
+  const sampleRate = optionalPositiveNumber(request.sampleRate);
+  const result = await callIosHost(
+    "eliza_tts_synthesize",
+    {
+      bundleDir,
+      text: request.text,
+      ...request.voice || request.voiceId ? { speakerPresetId: request.voice ?? request.voiceId } : {},
+      maxSamples: sampleRate ? Math.round(sampleRate * 60) : 24e3 * 60
+    },
+    18e4
+  );
+  const record = result && typeof result === "object" && !Array.isArray(result) ? result : {};
+  const audioFilePath = record.audioFilePath;
+  if (typeof audioFilePath === "string" && audioFilePath.trim()) {
+    const resolvedAudioFilePath = audioFilePath.trim();
+    const bytes = readFileSync2(resolvedAudioFilePath);
+    rmSync2(resolvedAudioFilePath, { force: true });
+    return normalizeAudioBytes(bytes);
+  }
+  const audioBase64 = record.audioBase64;
+  if (typeof audioBase64 !== "string" || audioBase64.length === 0) {
+    throw new Error("Native iOS local TTS returned no audio");
+  }
+  return normalizeAudioBytes(Buffer.from(audioBase64, "base64"));
+}
+async function handleNativeIosLocalTtsRoute(method, rawPath, payload) {
+  const { pathname } = splitPathAndQuery(rawPath);
+  if (method !== "POST" || pathname !== "/api/tts/local-inference") {
+    return null;
+  }
+  const body = parseRequestBody(payload);
+  const text = typeof body.text === "string" ? sanitizeLocalInferenceSpeechText(body.text) : "";
+  if (!text) {
+    return jsonResponse(400, { error: "Missing text" });
+  }
+  const voiceReadiness = nativeVoiceReadiness();
+  if (voiceReadiness.status !== "ready" && voiceReadiness.status !== "engine-ready" && voiceReadiness.status !== "assets-ready") {
+    return jsonResponse(503, {
+      error: voiceReadiness.message,
+      code: voiceReadiness.status === "unavailable" ? "ios_local_tts_executor_missing" : "ios_local_voice_assets_missing",
+      voiceReadiness
+    });
+  }
+  const request = {
+    text,
+    ...optionalString(body.voice) ? { voice: optionalString(body.voice) } : {},
+    ...optionalString(body.voiceId) ? { voice: optionalString(body.voiceId) } : {},
+    ...optionalString(body.model) ? { model: optionalString(body.model) } : {},
+    ...optionalString(body.modelId) ? { modelId: optionalString(body.modelId) } : {},
+    ...optionalPositiveNumber(body.speed) ? { speed: optionalPositiveNumber(body.speed) } : {},
+    ...optionalPositiveNumber(body.sampleRate) ? { sampleRate: optionalPositiveNumber(body.sampleRate) } : {},
+    ...optionalString(body.format) ? { format: optionalString(body.format) } : {}
+  };
+  try {
+    const bytes = await synthesizeNativeIosLocalTts(request);
+    if (bytes.length === 0) {
+      return jsonResponse(502, {
+        error: "Local inference TEXT_TO_SPEECH returned empty audio"
+      });
+    }
+    return bytesResponse(200, bytes, {
+      "content-type": sniffAudioContentType(bytes),
+      "cache-control": "no-store",
+      "content-length": String(bytes.byteLength)
+    });
+  } catch (error) {
+    return jsonResponse(502, {
+      error: `Local inference TTS error: ${error instanceof Error ? error.message : String(error)}`,
+      code: "ios_local_tts_failed"
+    });
+  }
+}
+async function transcribeNativeIosLocalAsr(request) {
+  const bundleDir = nativeVoiceBundleDir();
+  if (!bundleDir) {
+    throw new Error("No Eliza-1 voice bundle is installed");
+  }
+  const sampleRate = optionalPositiveNumber(request.sampleRate) ?? 16e3;
+  const result = await callIosHost(
+    "eliza_asr_transcribe",
+    {
+      bundleDir,
+      pcm: request.pcm,
+      sampleRate
+    },
+    18e4
+  );
+  const record = result && typeof result === "object" && !Array.isArray(result) ? result : {};
+  const text = record.text;
+  if (typeof text !== "string") {
+    throw new Error("Native iOS local ASR returned no transcript");
+  }
+  return text;
+}
+function parsePcmFloatArray(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    return null;
+  }
+  const pcm = [];
+  for (const sample of value) {
+    if (typeof sample !== "number" || !Number.isFinite(sample)) {
+      return null;
+    }
+    pcm.push(sample);
+  }
+  return pcm;
+}
+async function handleNativeIosLocalAsrRoute(method, rawPath, payload) {
+  const { pathname } = splitPathAndQuery(rawPath);
+  if (method !== "POST" || pathname !== "/api/asr/local-inference") {
+    return null;
+  }
+  const body = parseRequestBody(payload);
+  const pcm = parsePcmFloatArray(body.pcm ?? body.audio);
+  if (!pcm) {
+    return null;
+  }
+  const voiceReadiness = nativeVoiceReadiness();
+  if (voiceReadiness.status !== "ready" && voiceReadiness.status !== "engine-ready" && voiceReadiness.status !== "assets-ready") {
+    return jsonResponse(503, {
+      error: voiceReadiness.message,
+      code: voiceReadiness.status === "unavailable" ? "ios_local_asr_executor_missing" : "ios_local_voice_assets_missing",
+      voiceReadiness
+    });
+  }
+  const request = {
+    pcm,
+    ...optionalPositiveNumber(body.sampleRate) ? { sampleRate: optionalPositiveNumber(body.sampleRate) } : {}
+  };
+  try {
+    const text = await transcribeNativeIosLocalAsr(request);
+    return jsonResponse(200, { text });
+  } catch (error) {
+    return jsonResponse(502, {
+      error: `Local inference ASR error: ${error instanceof Error ? error.message : String(error)}`,
+      code: "ios_local_asr_failed"
+    });
+  }
+}
+async function handleNativeIosLocalInferenceRoute(method, rawPath, payload) {
+  const { pathname } = splitPathAndQuery(rawPath);
+  if (method === "GET" && pathname === "/api/local-inference/device") {
+    return jsonResponse(200, await nativeLlamaDeviceStatus());
+  }
+  if (method === "GET" && pathname === "/api/local-inference/providers") {
+    return jsonResponse(200, await nativeLocalInferenceProviders());
+  }
+  if (method === "GET" && pathname === "/api/local-inference/hardware") {
+    return jsonResponse(200, (await nativeHubSnapshot()).hardware);
+  }
+  if (method === "GET" && pathname === "/api/local-inference/catalog") {
+    return jsonResponse(200, { models: nativeCatalogModels() });
+  }
+  if (method === "GET" && pathname === "/api/local-inference/installed") {
+    return jsonResponse(200, { models: readInstalledModels() });
+  }
+  if (method === "GET" && pathname === "/api/local-inference/downloads") {
+    return jsonResponse(200, { downloads: nativeDownloadJobs() });
+  }
+  if (method === "POST" && pathname === "/api/local-inference/downloads") {
+    const body = parseRequestBody(payload);
+    const modelId = typeof body.modelId === "string" ? body.modelId : body.spec && typeof body.spec === "object" && !Array.isArray(body.spec) && typeof body.spec.id === "string" ? body.spec.id : "";
+    if (!modelId) {
+      return jsonResponse(400, { error: "Missing modelId" });
+    }
+    try {
+      return jsonResponse(200, { job: startNativeModelDownload(modelId) });
+    } catch (error) {
+      return jsonResponse(400, {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  if (method === "GET" && pathname === "/api/local-inference/routing") {
+    return jsonResponse(200, routingPreferencesSnapshot());
+  }
+  if (method === "GET" && pathname === "/api/local-inference/assignments") {
+    return jsonResponse(200, { assignments: readAssignments() });
+  }
+  if (method === "POST" && pathname === "/api/local-inference/assignments") {
+    const body = parseRequestBody(payload);
+    const slot = typeof body.slot === "string" ? body.slot : "";
+    const modelId = typeof body.modelId === "string" ? body.modelId : null;
+    if (!IOS_NATIVE_ASSIGNMENT_SLOTS.has(slot)) {
+      return jsonResponse(400, {
+        error: `Unsupported assignment slot: ${slot}`
+      });
+    }
+    if (modelId) {
+      const installed = readInstalledModels();
+      const known = installed.some((model) => model.id === modelId) || iosNativeCatalogById(modelId) != null || nativeDownloadState.has(modelId);
+      if (!known) {
+        return jsonResponse(404, { error: `Unknown local model: ${modelId}` });
+      }
+    }
+    const assignments = readAssignments();
+    if (modelId) assignments[slot] = modelId;
+    else delete assignments[slot];
+    writeAssignments(assignments);
+    return jsonResponse(200, { assignments });
+  }
+  if (method === "GET" && pathname === "/api/local-inference/active") {
+    return jsonResponse(200, nativeLlamaActiveSnapshot());
+  }
+  if (method === "POST" && pathname === "/api/local-inference/active") {
+    const body = parseRequestBody(payload);
+    const modelId = typeof body.modelId === "string" ? body.modelId : "";
+    const installed = readInstalledModels();
+    const target = installed.find((model) => model.id === modelId);
+    if (!target) {
+      return jsonResponse(404, { error: `Model not installed: ${modelId}` });
+    }
+    mkdirSync2(localInferenceRootPath(), { recursive: true });
+    nativeLlamaState.modelId = target.id;
+    nativeLlamaState.modelPath = target.path;
+    await ensureNativeModelLoaded("TEXT_SMALL");
+    return jsonResponse(200, nativeLlamaActiveSnapshot());
+  }
+  if (method === "DELETE" && pathname === "/api/local-inference/active") {
+    await unloadNativeLlamaModel();
+    return jsonResponse(200, nativeLlamaActiveSnapshot());
+  }
+  if (method === "GET" && pathname === "/api/local-inference/hub") {
+    return jsonResponse(200, await nativeHubSnapshot());
+  }
+  const verifyMatch = pathname.match(
+    /^\/api\/local-inference\/installed\/([^/]+)\/verify$/
+  );
+  if (method === "POST" && verifyMatch?.[1]) {
+    const id = decodeURIComponent(verifyMatch[1]);
+    const model = readInstalledModels().find((entry) => entry.id === id);
+    if (!model)
+      return jsonResponse(404, { error: `Model not installed: ${id}` });
+    return jsonResponse(200, {
+      ok: true,
+      modelId: model.id,
+      path: model.path,
+      sizeBytes: model.sizeBytes ?? 0,
+      verifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  return null;
+}
+async function handleBufferedLocalInferenceRoute(method, rawPath, payload) {
+  const { pathname } = splitPathAndQuery(rawPath);
+  if (!pathname.startsWith("/api/local-inference/")) return null;
+  if (method === "GET" && (pathname === "/api/local-inference/downloads/stream" || pathname === "/api/local-inference/device/stream")) {
+    return jsonResponse(501, {
+      error: "Streaming local-inference endpoints are not available over the iOS stdio bridge",
+      code: "streaming_not_supported"
+    });
+  }
+  const native = await handleNativeIosLocalInferenceRoute(
+    method,
+    rawPath,
+    payload
+  );
+  if (native) return native;
+  return null;
+}
+async function ensureConversationConnection(backend, conversation) {
+  const runtime = backend.runtime;
+  const userId = stringToUuid("ios-local-user");
+  if (typeof runtime.ensureConnection === "function") {
+    await runtime.ensureConnection({
+      entityId: userId,
+      roomId: conversation.roomId,
+      worldId: stringToUuid("ios-local-world"),
+      userName: "User",
+      source: "ios-local",
+      channelId: "ios-local-chat",
+      type: ChannelType.DM,
+      messageServerId: stringToUuid("ios-local-server"),
+      metadata: { ownership: { ownerId: userId } }
+    });
+  }
+  return userId;
+}
+async function handleDirectConversationMessage(backend, conversation, input) {
+  const prompt = typeof input.text === "string" ? input.text : typeof input.message === "string" ? input.message : typeof input.prompt === "string" ? input.prompt : "";
+  if (!prompt.trim()) throw new Error("message text is required");
+  const runtime = backend.runtime;
+  const userId = await ensureConversationConnection(backend, conversation);
+  const channelType = typeof input.channelType === "string" && Object.values(ChannelType).includes(input.channelType) ? input.channelType : ChannelType.DM;
+  const metadata = input.metadata && typeof input.metadata === "object" && !Array.isArray(input.metadata) ? input.metadata : void 0;
+  const message = createMessageMemory({
+    id: crypto.randomUUID(),
+    entityId: userId,
+    roomId: conversation.roomId,
+    content: {
+      text: prompt,
+      source: "ios-local",
+      channelType,
+      ...metadata ? { metadata } : {}
+    }
+  });
+  try {
+    await runtime.createMemory?.(message, "messages");
+  } catch {
+  }
+  const nativeReply = await maybeGenerateIosNativeConversationReply(
+    backend.runtime,
+    prompt
+  ).catch((error) => ({
+    text: error instanceof Error ? `The local Eliza-1 model is installed, but generation failed: ${error.message}` : "The local Eliza-1 model is installed, but generation failed.",
+    reply: error instanceof Error ? `The local Eliza-1 model is installed, but generation failed: ${error.message}` : "The local Eliza-1 model is installed, but generation failed.",
+    localInference: {
+      provider: IOS_NATIVE_LLAMA_PROVIDER,
+      mode: "ios_native_conversation",
+      error: error instanceof Error ? error.message : String(error)
+    }
+  }));
+  if (nativeReply) {
+    const agentName2 = runtimeAgentName(backend.runtime);
+    conversation.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    conversation.lastUserText = prompt.trim();
+    conversation.lastAssistantText = typeof nativeReply.text === "string" ? nativeReply.text : "";
+    conversation.lastAgentName = agentName2;
+    return {
+      ...nativeReply,
+      agentName: agentName2,
+      conversationId: conversation.id
+    };
+  }
+  if (!runtime.messageService?.handleMessage) {
+    throw new Error("runtime.messageService is not available");
+  }
+  const chunks = [];
+  try {
+    await runtime.messageService.handleMessage(
+      runtime,
+      message,
+      async (content) => {
+        if (content?.text) chunks.push(content.text);
+        return [];
+      }
+    );
+  } catch (err) {
+    chunks.push(
+      err instanceof Error ? `The local agent started, but generation is unavailable: ${err.message}` : "The local agent started, but generation is unavailable."
+    );
+  }
+  const text = stripReasoningBlocks(chunks.join("")).trim();
+  const agentName = runtimeAgentName(backend.runtime);
+  conversation.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  conversation.lastUserText = prompt.trim();
+  conversation.lastAssistantText = text;
+  conversation.lastAgentName = agentName;
+  return {
+    text,
+    reply: text,
+    agentName,
+    conversationId: conversation.id
+  };
+}
+function cachedConversationMessageResult(conversation, input) {
+  const prompt = typeof input.text === "string" ? input.text : typeof input.message === "string" ? input.message : typeof input.prompt === "string" ? input.prompt : "";
+  if (!conversation.lastAssistantText || !conversation.lastUserText || conversation.lastUserText !== prompt.trim()) {
+    return null;
+  }
+  return {
+    text: conversation.lastAssistantText,
+    reply: conversation.lastAssistantText,
+    agentName: conversation.lastAgentName ?? "Eliza",
+    conversationId: conversation.id,
+    cached: true
+  };
+}
+function sseEvent(payload) {
+  return `data: ${JSON.stringify(payload)}
+
+`;
+}
+function bufferedConversationStreamResponse(result) {
+  const text = typeof result.text === "string" ? result.text : "";
+  const agentName = typeof result.agentName === "string" && result.agentName.trim() ? result.agentName : "Eliza";
+  const body = [
+    ...text ? [sseEvent({ type: "token", text, fullText: text })] : [],
+    sseEvent({
+      type: "done",
+      fullText: text,
+      agentName,
+      completed: true,
+      ...typeof result.failureKind === "string" ? { failureKind: result.failureKind } : {},
+      ...result.localInference && typeof result.localInference === "object" && !Array.isArray(result.localInference) ? { localInference: result.localInference } : {}
+    })
+  ].join("");
+  return {
+    status: 200,
+    statusText: statusTextForCode(200),
+    headers: {
+      "content-type": "text/event-stream; charset=utf-8",
+      "cache-control": "no-cache, no-transform",
+      connection: "keep-alive"
+    },
+    body,
+    bodyBase64: Buffer.from(body, "utf8").toString("base64"),
+    bodyEncoding: "utf-8"
+  };
+}
+async function handleDirectCoreRoute(backend, method, rawPath, payload) {
+  const { pathname } = splitPathAndQuery(rawPath);
+  if (method === "GET" && pathname === "/api/health") {
+    return jsonResponse(200, {
+      ready: true,
+      runtime: "ok",
+      database: "ok",
+      plugins: {
+        loaded: Array.isArray(
+          backend.runtime.plugins
+        ) ? backend.runtime.plugins?.length ?? 0 : 0,
+        failed: 0
+      },
+      coordinator: "not_wired",
+      agentState: "running",
+      agentName: runtimeAgentName(backend.runtime),
+      startedAt: null,
+      uptime: 0,
+      iosBridge: "bun"
+    });
+  }
+  if (method === "GET" && pathname === "/api/status") {
+    return jsonResponse(200, {
+      state: "running",
+      agentName: runtimeAgentName(backend.runtime),
+      model: null,
+      canRespond: true,
+      startedAt: null,
+      uptime: 0,
+      startup: { phase: "running", runtimePhase: "running" },
+      cloud: {
+        connectionStatus: "disconnected",
+        activeAgentId: null,
+        cloudProvisioned: false,
+        hasApiKey: false
+      },
+      pendingRestart: false,
+      pendingRestartReasons: [],
+      iosBridge: "bun"
+    });
+  }
+  if (method === "GET" && pathname === "/api/apps/runs") {
+    return jsonResponse(200, []);
+  }
+  if (method === "GET" && pathname === "/api/first-run/status") {
+    return jsonResponse(200, {
+      complete: true,
+      cloudProvisioned: false,
+      deploymentTarget: "local"
+    });
+  }
+  if (method === "POST" && pathname === "/api/first-run") {
+    return jsonResponse(200, {
+      ok: true,
+      complete: true,
+      deploymentTarget: "local"
+    });
+  }
+  if (method === "GET" && pathname === "/api/auth/me") {
+    return jsonResponse(200, {
+      identity: {
+        id: "local-agent",
+        displayName: "Local Agent",
+        kind: "machine"
+      },
+      session: { id: "local", kind: "local", expiresAt: null },
+      access: {
+        mode: "local",
+        passwordConfigured: false,
+        ownerConfigured: false
+      }
+    });
+  }
+  if (method === "GET" && pathname === "/api/auth/status") {
+    return jsonResponse(200, {
+      required: false,
+      pairingEnabled: false,
+      expiresAt: null,
+      authenticated: true,
+      localAccess: true
+    });
+  }
+  if (method === "POST" && pathname === "/api/dev/model-grind") {
+    const report = await runModelGrind({
+      callIosHost,
+      ensureTextModelLoaded: (slot) => ensureNativeModelLoaded(slot),
+      synthesizeTts: async (text) => ({
+        bytes: await synthesizeNativeIosLocalTts({ text }),
+        sampleRate: 24e3
+      }),
+      transcribeAsr: (pcm, sampleRate) => transcribeNativeIosLocalAsr({ pcm, sampleRate }),
+      hardwareInfo: () => nativeHardwareInfo(),
+      bundleDir: nativeVoiceBundleDir()
+    });
+    return jsonResponse(report.overall.allPassed ? 200 : 207, report);
+  }
+  const localTts = await handleNativeIosLocalTtsRoute(method, rawPath, payload);
+  if (localTts) return localTts;
+  const localAsr = await handleNativeIosLocalAsrRoute(method, rawPath, payload);
+  if (localAsr) return localAsr;
+  const localInference = await handleBufferedLocalInferenceRoute(
+    method,
+    rawPath,
+    payload
+  );
+  if (localInference) return localInference;
+  if (method === "GET" && pathname === "/api/conversations") {
+    return jsonResponse(200, {
+      conversations: Array.from(backend.conversations.values()).sort(
+        (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+      )
+    });
+  }
+  if (method === "POST" && pathname === "/api/conversations") {
+    const conversation = createIosConversation(
+      backend,
+      parseRequestBody(payload)
+    );
+    return jsonResponse(200, { conversation });
+  }
+  const messageMatch = pathname.match(
+    /^\/api\/conversations\/([^/]+)\/messages$/
+  );
+  const messageStreamMatch = pathname.match(
+    /^\/api\/conversations\/([^/]+)\/messages\/stream$/
+  );
+  if (method === "GET" && messageMatch) {
+    return jsonResponse(200, { messages: [] });
+  }
+  if (method === "POST" && messageStreamMatch) {
+    const conversationId = decodeURIComponent(messageStreamMatch[1] ?? "");
+    const conversation = backend.conversations.get(conversationId);
+    if (!conversation) {
+      return jsonResponse(404, { error: "Conversation not found" });
+    }
+    const body = parseRequestBody(payload);
+    const result = cachedConversationMessageResult(conversation, body) ?? await handleDirectConversationMessage(backend, conversation, body);
+    return bufferedConversationStreamResponse(result);
+  }
+  if (method === "POST" && messageMatch) {
+    const conversationId = decodeURIComponent(messageMatch[1] ?? "");
+    const conversation = backend.conversations.get(conversationId);
+    if (!conversation) {
+      return jsonResponse(404, { error: "Conversation not found" });
+    }
+    const result = await handleDirectConversationMessage(
+      backend,
+      conversation,
+      parseRequestBody(payload)
+    );
+    return jsonResponse(200, result);
+  }
+  return null;
+}
+async function sendMessage(backend, payload) {
+  const input = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+  const message = typeof input.message === "string" ? input.message : "";
+  if (!message.trim()) throw new Error("send_message requires message");
+  let conversationId = typeof input.conversationId === "string" && input.conversationId.trim() ? input.conversationId.trim() : "";
+  if (!conversationId) {
+    conversationId = createIosConversation(backend, {
+      title: "iOS Local Chat"
+    }).id;
+  }
+  const conversation = backend.conversations.get(conversationId);
+  if (!conversation) throw new Error("Conversation not found");
+  const result = await timeoutAfter(
+    handleDirectConversationMessage(backend, conversation, {
+      text: message,
+      channelType: typeof input.channelType === "string" ? input.channelType : "DM",
+      ...input.metadata && typeof input.metadata === "object" && !Array.isArray(input.metadata) ? { metadata: input.metadata } : {}
+    }),
+    bridgeTimeoutMs(input.timeoutMs),
+    "send_message"
+  );
+  if (isTimeoutMarker(result)) {
+    throw new Error(`${result.label} timed out after ${result.timeoutMs}ms`);
+  }
+  return { ...result, conversationId, response: result };
+}
+async function dispatchBridgeRequest(host, request) {
+  const method = typeof request.method === "string" ? request.method : "";
+  const payload = request.payload && typeof request.payload === "object" ? request.payload : {};
+  switch (method) {
+    case "status":
+      if (host.backend) {
+        return bridgeStatus();
+      }
+      if (host.bootError) {
+        return bridgeStatus({
+          ready: false,
+          phase: "error",
+          error: host.bootError instanceof Error ? host.bootError.message : String(host.bootError)
+        });
+      }
+      if (payload.timeoutMs !== void 0) {
+        await awaitIosBridgeBackend(
+          host,
+          bridgeTimeoutMs(payload.timeoutMs),
+          "status"
+        );
+        return bridgeStatus();
+      }
+      return bridgeStatus({ ready: false, phase: "starting" });
+    case "http_request":
+    case "http_fetch": {
+      const backendForFetch = await awaitIosBridgeBackend(
+        host,
+        bridgeTimeoutMs(payload.timeoutMs),
+        method
+      );
+      return fetchBackend(
+        backendForFetch,
+        request.payload ?? {}
+      );
+    }
+    case "send_message": {
+      const backendForMessage = await awaitIosBridgeBackend(
+        host,
+        bridgeTimeoutMs(payload.timeoutMs),
+        method
+      );
+      return sendMessage(backendForMessage, request.payload);
+    }
+    default:
+      throw new Error(`Unknown iOS bridge method: ${method || "(missing)"}`);
+  }
+}
+function reserveStdoutForBridgeProtocol() {
+  const stderrWrite = process2.stderr.write.bind(process2.stderr);
+  const originalStdoutWrite = process2.stdout.write.bind(process2.stdout);
+  const originalConsoleLog = console.log.bind(console);
+  const originalConsoleInfo = console.info.bind(console);
+  const originalConsoleDebug = console.debug.bind(console);
+  const assignments = [];
+  const tryAssign = (target, key, value, restore) => {
+    try {
+      target[key] = value;
+      assignments.push(restore);
+    } catch {
+    }
+  };
+  const writeToStderr = (chunk, encoding, cb) => {
+    if (typeof encoding === "function") {
+      return stderrWrite(chunk, encoding);
+    }
+    if (encoding) {
+      return cb ? stderrWrite(chunk, encoding, cb) : stderrWrite(chunk, encoding);
+    }
+    return cb ? stderrWrite(chunk, cb) : stderrWrite(chunk);
+  };
+  const stdoutWriteToStderr = ((chunk, encoding, cb) => writeToStderr(
+    chunk,
+    encoding,
+    cb
+  ));
+  tryAssign(process2.stdout, "write", stdoutWriteToStderr, () => {
+    process2.stdout.write = originalStdoutWrite;
+  });
+  tryAssign(
+    console,
+    "log",
+    ((...args) => console.error(...args)),
+    () => {
+      console.log = originalConsoleLog;
+    }
+  );
+  tryAssign(
+    console,
+    "info",
+    ((...args) => console.error(...args)),
+    () => {
+      console.info = originalConsoleInfo;
+    }
+  );
+  tryAssign(
+    console,
+    "debug",
+    ((...args) => console.error(...args)),
+    () => {
+      console.debug = originalConsoleDebug;
+    }
+  );
+  return () => {
+    for (let i = assignments.length - 1; i >= 0; i -= 1) {
+      try {
+        assignments[i]?.();
+      } catch {
+      }
+    }
+  };
+}
+async function runIosBridgeCli(argv = process2.argv) {
+  if (!argv.includes("--stdio")) {
+    throw new Error("ios-bridge currently supports --stdio only");
+  }
+  const protocolWrite = process2.stdout.write.bind(process2.stdout);
+  const restoreStdout = reserveStdoutForBridgeProtocol();
+  const writeProtocolLine = (value) => {
+    protocolWrite(`${JSON.stringify(value)}
+`);
+  };
+  installHostCallProtocol(writeProtocolLine);
+  const host = startIosBridgeHost();
+  process2.on("unhandledRejection", (reason) => {
+    console.error(
+      "[ios-bridge] unhandled rejection:",
+      reason instanceof Error ? reason.stack || reason.message : reason
+    );
+  });
+  process2.on("uncaughtException", (error) => {
+    console.error(
+      "[ios-bridge] uncaught exception:",
+      error.stack || error.message
+    );
+  });
+  writeProtocolLine({
+    type: "ready",
+    ok: true,
+    result: bridgeStatus({ ready: true })
+  });
+  const shutdown = async () => {
+    try {
+      if (host.backend) {
+        await host.backend.close();
+      }
+    } catch {
+    }
+  };
+  let stopBridge = null;
+  const stopPromise = new Promise((resolve) => {
+    stopBridge = resolve;
+  });
+  process2.once("SIGINT", () => stopBridge?.());
+  process2.once("SIGTERM", () => stopBridge?.());
+  const keepAlive = setInterval(() => {
+  }, 2147483647);
+  const handleLine = async (line) => {
+    if (!line.trim()) return;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch (err) {
+      writeProtocolLine({
+        id: null,
+        ok: false,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return;
+    }
+    const id = parsed.id ?? null;
+    try {
+      const result = await dispatchBridgeRequest(host, parsed);
+      writeProtocolLine({ id, ok: true, result });
+    } catch (err) {
+      writeProtocolLine({
+        id,
+        ok: false,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  };
+  let pending = Promise.resolve();
+  let bufferedInput = "";
+  const stdin = process2.stdin;
+  stdin.setEncoding?.("utf8");
+  stdin.on("data", (chunk) => {
+    bufferedInput += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    for (; ; ) {
+      const newline = bufferedInput.indexOf("\n");
+      if (newline < 0) break;
+      const line = bufferedInput.slice(0, newline).replace(/\r$/, "");
+      bufferedInput = bufferedInput.slice(newline + 1);
+      if (tryHandleHostResultLine(line)) continue;
+      pending = pending.then(() => handleLine(line)).catch((err) => {
+        writeProtocolLine({
+          id: null,
+          ok: false,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
+    }
+  });
+  stdin.once("end", () => {
+    if (bufferedInput.trim()) {
+      const line = bufferedInput;
+      bufferedInput = "";
+      if (!tryHandleHostResultLine(line)) {
+        pending = pending.then(() => handleLine(line));
+      }
+    }
+    stopBridge?.();
+  });
+  stdin.once("error", (err) => {
+    writeProtocolLine({
+      id: null,
+      ok: false,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    stopBridge?.();
+  });
+  stdin.resume?.();
+  await stopPromise;
+  clearInterval(keepAlive);
+  await pending.catch(() => void 0);
+  restoreStdout();
+  await shutdown();
+}
+export {
+  runIosBridgeCli
+};