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

package/dist/chunk-Q2XW27TY.js

@@ -0,0 +1,1234 @@
+// src/mobile-device-bridge-bootstrap.ts
+import { randomUUID } from "crypto";
+import {
+  createWriteStream,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  unlinkSync
+} from "fs";
+import net from "net";
+import path from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+import {
+  logger,
+  ModelType,
+  resolveStateDir
+} from "@elizaos/core";
+var DEVICE_BRIDGE_PATH = "/api/local-inference/device-bridge";
+var PROVIDER = "capacitor-llama";
+var LOCAL_INFERENCE_PRIORITY = 0;
+var DEFAULT_NATIVE_REQUEST_TIMEOUT_MS = 6e5;
+var DEFAULT_CALL_TIMEOUT_MS = DEFAULT_NATIVE_REQUEST_TIMEOUT_MS;
+var DEFAULT_LOAD_TIMEOUT_MS = DEFAULT_NATIVE_REQUEST_TIMEOUT_MS;
+var SERVICE_ENABLED = process.env.ELIZA_DEVICE_BRIDGE_ENABLED?.trim() === "1";
+var registeredRuntimes = /* @__PURE__ */ new WeakSet();
+var KNOWN_EMBEDDING_DIMENSIONS = {
+  "eliza-1-embedding": 1024,
+  // 2B reuses the text backbone for embeddings (--pooling last), so its dim is the
+  // model's embedding_length = 2048 (device-verified: EMBED -> dim 2048), NOT 1536.
+  "eliza-1-2b": 2048,
+  "eliza-1-4b": 2560
+};
+var GEMMA_MTP_DRAFT = { draftMin: 1, draftMax: 1 };
+var ELIZA_1_LOAD_METADATA = {
+  // 2B is the smallest/entry tier (the small-phone default). Every shipped
+  // tier can use a Gemma 4 assistant drafter when that companion GGUF is
+  // staged next to the bundle. The bridge never falls back to same-file MTP
+  // because that was the retired Qwen contract.
+  "eliza-1-2b": {
+    contextSize: 131072,
+    mtp: { drafterFile: "mtp/drafter-2b.gguf", ...GEMMA_MTP_DRAFT }
+  },
+  "eliza-1-4b": {
+    contextSize: 65536,
+    mtp: { drafterFile: "mtp/drafter-4b.gguf", ...GEMMA_MTP_DRAFT }
+  },
+  "eliza-1-9b": {
+    contextSize: 65536,
+    mtp: { drafterFile: "mtp/drafter-9b.gguf", ...GEMMA_MTP_DRAFT }
+  },
+  "eliza-1-27b": {
+    contextSize: 131072,
+    mtp: { drafterFile: "mtp/drafter-27b.gguf", ...GEMMA_MTP_DRAFT }
+  },
+  "eliza-1-27b-256k": {
+    contextSize: 262144,
+    mtp: { drafterFile: "mtp/drafter-27b-256k.gguf", ...GEMMA_MTP_DRAFT }
+  }
+};
+function bionicMtpOverride() {
+  const raw = process.env.ELIZA_BIONIC_MTP?.trim().toLowerCase();
+  if (!raw) return void 0;
+  if (raw === "0" || raw === "false" || raw === "no" || raw === "off") {
+    return false;
+  }
+  if (raw === "1" || raw === "true" || raw === "yes" || raw === "on") {
+    return true;
+  }
+  return void 0;
+}
+function isWsModule(value) {
+  return typeof value === "object" && value !== null && typeof value.WebSocketServer === "function" && typeof value.WebSocket === "function";
+}
+var MobileDeviceBridge = class {
+  wss = null;
+  devices = /* @__PURE__ */ new Map();
+  pendingLoads = /* @__PURE__ */ new Map();
+  pendingUnloads = /* @__PURE__ */ new Map();
+  pendingGenerates = /* @__PURE__ */ new Map();
+  pendingEmbeds = /* @__PURE__ */ new Map();
+  pendingFormatChats = /* @__PURE__ */ new Map();
+  expectedPairingToken = process.env.ELIZA_DEVICE_PAIRING_TOKEN?.trim() || process.env.ELIZA_DEVICE_BRIDGE_TOKEN?.trim() || null;
+  status() {
+    const devices = [...this.devices.values()].map((device) => ({
+      deviceId: device.deviceId,
+      capabilities: device.capabilities,
+      loadedPath: device.loadedPath,
+      connectedSince: new Date(device.connectedAt).toISOString()
+    }));
+    return {
+      enabled: SERVICE_ENABLED && Boolean(this.expectedPairingToken),
+      connected: devices.length > 0,
+      devices,
+      primaryDeviceId: devices[0]?.deviceId ?? null,
+      pendingRequests: this.pendingLoads.size + this.pendingUnloads.size + this.pendingGenerates.size + this.pendingEmbeds.size,
+      modelPath: resolveLocalModelPath("TEXT_LARGE")
+    };
+  }
+  async attachToHttpServer(server) {
+    if (!SERVICE_ENABLED || this.wss) return;
+    if (!this.expectedPairingToken) {
+      logger.warn(
+        "[mobile-device-bridge] Disabled: ELIZA_DEVICE_PAIRING_TOKEN is required when ELIZA_DEVICE_BRIDGE_ENABLED=1"
+      );
+      return;
+    }
+    const wsModule = await import("ws");
+    if (!isWsModule(wsModule)) {
+      throw new Error("ws module did not expose WebSocketServer/WebSocket");
+    }
+    const ws = wsModule;
+    const wss = new ws.WebSocketServer({
+      noServer: true,
+      maxPayload: 1024 * 1024
+    });
+    this.wss = wss;
+    wss.on("error", (err) => {
+      logger.warn("[mobile-device-bridge] WSS error:", err.message);
+    });
+    server.on("upgrade", (request, socket, head) => {
+      const url = new URL(request.url ?? "/", "http://localhost");
+      if (url.pathname !== DEVICE_BRIDGE_PATH) return;
+      wss.handleUpgrade(request, socket, head, (client) => {
+        this.handleConnection(client, ws.WebSocket, url);
+      });
+    });
+    logger.info(
+      `[mobile-device-bridge] Listening for Capacitor device bridge at ${DEVICE_BRIDGE_PATH}`
+    );
+  }
+  handleConnection(socket, WsCtor, url) {
+    const queryToken = url.searchParams.get("token")?.trim();
+    if (!this.expectedPairingToken || queryToken !== this.expectedPairingToken) {
+      logger.warn(
+        "[mobile-device-bridge] Rejecting connection: bad query token"
+      );
+      socket.close(4001, "unauthorized");
+      return;
+    }
+    let registeredDeviceId = null;
+    socket.on("message", (raw) => {
+      let msg;
+      try {
+        const text = typeof raw === "string" ? raw : raw.toString("utf8");
+        msg = JSON.parse(text);
+      } catch {
+        logger.warn("[mobile-device-bridge] Ignoring non-JSON frame");
+        return;
+      }
+      if (!registeredDeviceId) {
+        if (msg.type !== "register") {
+          socket.close(4002, "must-register-first");
+          return;
+        }
+        if (msg.payload.capabilities.platform === "ios") {
+          logger.warn(
+            "[mobile-device-bridge] Rejecting iOS registration: use native IPC"
+          );
+          socket.close(4003, "ios-ipc-required");
+          return;
+        }
+        if (!this.expectedPairingToken || msg.payload.pairingToken !== this.expectedPairingToken) {
+          logger.warn(
+            "[mobile-device-bridge] Rejecting register: bad pairing token"
+          );
+          socket.close(4001, "unauthorized");
+          return;
+        }
+        registeredDeviceId = msg.payload.deviceId;
+        this.devices.set(registeredDeviceId, {
+          deviceId: registeredDeviceId,
+          socket,
+          capabilities: msg.payload.capabilities,
+          loadedPath: msg.payload.loadedPath,
+          connectedAt: Date.now()
+        });
+        logger.info(
+          `[mobile-device-bridge] Device connected: ${registeredDeviceId} (${msg.payload.capabilities.platform})`
+        );
+        return;
+      }
+      this.handleDeviceMessage(msg);
+    });
+    socket.on("close", () => {
+      if (!registeredDeviceId) return;
+      const current = this.devices.get(registeredDeviceId);
+      if (current?.socket === socket) {
+        this.devices.delete(registeredDeviceId);
+        logger.info(
+          `[mobile-device-bridge] Device disconnected: ${registeredDeviceId}`
+        );
+      }
+    });
+    socket.on("error", (err) => {
+      logger.warn("[mobile-device-bridge] Socket error:", err.message);
+    });
+    const heartbeat = setInterval(() => {
+      if (!registeredDeviceId || socket.readyState !== WsCtor.OPEN) return;
+      try {
+        socket.send(JSON.stringify({ type: "ping", at: Date.now() }));
+      } catch {
+        clearInterval(heartbeat);
+      }
+    }, 15e3);
+    if (typeof heartbeat === "object" && "unref" in heartbeat) {
+      heartbeat.unref();
+    }
+  }
+  handleDeviceMessage(msg) {
+    if (msg.type === "pong" || msg.type === "register") return;
+    if (msg.type === "loadResult") {
+      const pending = this.pendingLoads.get(msg.correlationId);
+      if (!pending) return;
+      clearTimeout(pending.timeout);
+      this.pendingLoads.delete(msg.correlationId);
+      if (msg.ok === true) {
+        const device = this.devices.get(pending.routedDeviceId);
+        if (device) device.loadedPath = msg.loadedPath;
+        pending.resolve(void 0);
+      } else {
+        pending.reject(new Error(msg.error));
+      }
+      return;
+    }
+    if (msg.type === "unloadResult") {
+      const pending = this.pendingUnloads.get(msg.correlationId);
+      if (!pending) return;
+      clearTimeout(pending.timeout);
+      this.pendingUnloads.delete(msg.correlationId);
+      if (msg.ok === true) {
+        const device = this.devices.get(pending.routedDeviceId);
+        if (device) device.loadedPath = null;
+        pending.resolve(void 0);
+      } else {
+        pending.reject(new Error(msg.error));
+      }
+      return;
+    }
+    if (msg.type === "generateResult") {
+      const pending = this.pendingGenerates.get(msg.correlationId);
+      if (!pending) return;
+      clearTimeout(pending.timeout);
+      this.pendingGenerates.delete(msg.correlationId);
+      if (msg.ok === true) {
+        pending.resolve(msg.text);
+      } else {
+        pending.reject(new Error(msg.error));
+      }
+      return;
+    }
+    if (msg.type === "embedResult") {
+      const pending = this.pendingEmbeds.get(msg.correlationId);
+      if (!pending) return;
+      clearTimeout(pending.timeout);
+      this.pendingEmbeds.delete(msg.correlationId);
+      if (msg.ok === true) {
+        pending.resolve(msg.embedding);
+      } else {
+        pending.reject(new Error(msg.error));
+      }
+      return;
+    }
+    if (msg.type === "formatChatResult") {
+      const pending = this.pendingFormatChats.get(msg.correlationId);
+      if (!pending) return;
+      clearTimeout(pending.timeout);
+      this.pendingFormatChats.delete(msg.correlationId);
+      if (msg.ok === true) {
+        pending.resolve(msg.prompt);
+      } else {
+        pending.reject(new Error(msg.error));
+      }
+    }
+  }
+  primaryDevice() {
+    return this.devices.values().next().value ?? null;
+  }
+  sendToPrimary(pendingMap, makeMessage, timeoutMs, timeoutMessage) {
+    const device = this.primaryDevice();
+    if (!device) {
+      return Promise.reject(
+        new Error(
+          "DEVICE_DISCONNECTED: no Capacitor llama device bridge attached"
+        )
+      );
+    }
+    const correlationId = randomUUID();
+    const message = makeMessage(correlationId);
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        pendingMap.delete(correlationId);
+        reject(new Error(timeoutMessage));
+      }, timeoutMs);
+      if (typeof timeout === "object" && "unref" in timeout) {
+        timeout.unref();
+      }
+      pendingMap.set(correlationId, {
+        resolve,
+        reject,
+        timeout,
+        routedDeviceId: device.deviceId
+      });
+      try {
+        device.socket.send(JSON.stringify(message));
+      } catch (err) {
+        clearTimeout(timeout);
+        pendingMap.delete(correlationId);
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+  async loadModel(args) {
+    const device = this.primaryDevice();
+    if (device?.loadedPath === args.modelPath) return;
+    return this.sendToPrimary(
+      this.pendingLoads,
+      (correlationId) => ({
+        type: "load",
+        correlationId,
+        ...args
+      }),
+      readTimeoutMs("ELIZA_DEVICE_LOAD_TIMEOUT_MS", DEFAULT_LOAD_TIMEOUT_MS),
+      "DEVICE_TIMEOUT: model load exceeded deadline"
+    );
+  }
+  async unloadModel() {
+    const device = this.primaryDevice();
+    if (!device?.loadedPath) return;
+    return this.sendToPrimary(
+      this.pendingUnloads,
+      (correlationId) => ({ type: "unload", correlationId }),
+      readTimeoutMs(
+        "ELIZA_DEVICE_GENERATE_TIMEOUT_MS",
+        DEFAULT_CALL_TIMEOUT_MS
+      ),
+      "DEVICE_TIMEOUT: unload exceeded deadline"
+    );
+  }
+  generate(args) {
+    return this.sendToPrimary(
+      this.pendingGenerates,
+      (correlationId) => ({
+        type: "generate",
+        correlationId,
+        prompt: args.prompt,
+        stopSequences: args.stopSequences,
+        maxTokens: args.maxTokens,
+        temperature: args.temperature
+      }),
+      readTimeoutMs(
+        "ELIZA_DEVICE_GENERATE_TIMEOUT_MS",
+        DEFAULT_CALL_TIMEOUT_MS
+      ),
+      "DEVICE_TIMEOUT: no device responded within deadline"
+    );
+  }
+  embed(args) {
+    return this.sendToPrimary(
+      this.pendingEmbeds,
+      (correlationId) => ({
+        type: "embed",
+        correlationId,
+        input: args.input
+      }),
+      readTimeoutMs("ELIZA_DEVICE_EMBED_TIMEOUT_MS", DEFAULT_CALL_TIMEOUT_MS),
+      "DEVICE_TIMEOUT: no device returned embeddings within deadline"
+    );
+  }
+  /**
+   * Apply the model's native chat template (Jinja, from the GGUF) to the
+   * given message list. Round-trips to the WebView so the Capacitor
+   * `LlamaCpp.getFormattedChat()` plugin call can invoke llama.cpp's
+   * `llama_chat_apply_template`. Returns the fully tokenized chat
+   * prompt string ready to feed back into `generate()`. Returns `null`
+   * when the loaded model has no chat template baked in (caller should
+   * fall back to a manual flatten in that case).
+   */
+  formatChat(messages) {
+    return this.sendToPrimary(
+      this.pendingFormatChats,
+      (correlationId) => ({
+        type: "formatChat",
+        correlationId,
+        messages
+      }),
+      readTimeoutMs("ELIZA_DEVICE_LOAD_TIMEOUT_MS", DEFAULT_LOAD_TIMEOUT_MS),
+      "DEVICE_TIMEOUT: chat template format exceeded deadline"
+    );
+  }
+};
+var mobileDeviceBridge = new MobileDeviceBridge();
+function readTimeoutMs(envKey, fallback) {
+  const parsed = Number.parseInt(process.env[envKey]?.trim() ?? "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function modelsDir() {
+  return path.join(resolveStateDir(), "local-inference", "models");
+}
+function registryPath() {
+  return path.join(resolveStateDir(), "local-inference", "registry.json");
+}
+function assignmentsPath() {
+  return path.join(resolveStateDir(), "local-inference", "assignments.json");
+}
+function readJsonFile(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function positiveInteger(value) {
+  const numeric = typeof value === "number" ? value : typeof value === "string" ? Number.parseInt(value, 10) : Number.NaN;
+  return Number.isInteger(numeric) && numeric > 0 ? numeric : null;
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function resolveFromEnv(slot) {
+  const key = slot === "TEXT_EMBEDDING" ? "ELIZA_LOCAL_EMBEDDING_MODEL_PATH" : "ELIZA_LOCAL_CHAT_MODEL_PATH";
+  const specific = process.env[key]?.trim();
+  if (specific && existsSync(specific)) return specific;
+  const fallback = process.env.ELIZA_LOCAL_MODEL_PATH?.trim();
+  if (fallback && existsSync(fallback)) return fallback;
+  return null;
+}
+function resolveFromRegistry(slot) {
+  const assignments = readJsonFile(
+    assignmentsPath()
+  )?.assignments;
+  const assigned = assignments?.[slot];
+  if (typeof assigned !== "string" || !assigned.trim()) return null;
+  const models = readRegistryModels();
+  const matched = models.find((model) => model.id === assigned);
+  return typeof matched?.path === "string" && existsSync(matched.path) ? matched.path : null;
+}
+function readRegistryModels() {
+  return readJsonFile(registryPath())?.models ?? [];
+}
+function resolveAssignedRegistryModel(slot) {
+  const assignments = readJsonFile(
+    assignmentsPath()
+  )?.assignments;
+  const assigned = assignments?.[slot];
+  if (typeof assigned !== "string" || !assigned.trim()) return null;
+  const models = readRegistryModels();
+  const matched = models.find((model) => model.id === assigned);
+  if (typeof matched?.path !== "string" || !existsSync(matched.path)) {
+    return null;
+  }
+  return {
+    id: assigned,
+    path: matched.path,
+    dimensions: matched.dimensions,
+    embeddingDimension: matched.embeddingDimension,
+    embeddingDimensions: matched.embeddingDimensions
+  };
+}
+function resolveManifestModel(slot) {
+  const manifest = readJsonFile(
+    path.join(modelsDir(), "manifest.json")
+  );
+  const targetRole = slot === "TEXT_EMBEDDING" ? "embedding" : "chat";
+  for (const entry of manifest?.models ?? []) {
+    if (entry.role !== targetRole) continue;
+    const fileName = entry.ggufFile ?? entry.filename;
+    if (!fileName) continue;
+    const absolute = path.join(modelsDir(), fileName);
+    if (existsSync(absolute)) return { path: absolute, entry };
+  }
+  return null;
+}
+function resolveFromManifest(slot) {
+  return resolveManifestModel(slot)?.path ?? null;
+}
+function drafterCandidates(modelPath, drafterFile) {
+  const modelDir = path.dirname(modelPath);
+  const basename = path.basename(drafterFile);
+  const candidates = /* @__PURE__ */ new Set();
+  if (path.basename(modelDir) === "text") {
+    const bundleRoot = path.dirname(modelDir);
+    candidates.add(path.join(bundleRoot, drafterFile));
+  }
+  candidates.add(path.join(modelDir, drafterFile));
+  candidates.add(path.join(modelDir, basename));
+  candidates.add(path.join(modelsDir(), drafterFile));
+  candidates.add(path.join(modelsDir(), basename));
+  return [...candidates];
+}
+function resolveGemmaDrafterPath(modelPath, drafterFile) {
+  for (const candidate of drafterCandidates(modelPath, drafterFile)) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function resolveFirstGguf() {
+  const dir = modelsDir();
+  if (!existsSync(dir)) return null;
+  for (const name of readdirSync(dir)) {
+    if (!name.toLowerCase().endsWith(".gguf")) continue;
+    const absolute = path.join(dir, name);
+    if (existsSync(absolute)) return absolute;
+  }
+  return null;
+}
+function resolveLocalModelPath(slot) {
+  return resolveFromEnv(slot) ?? resolveFromRegistry(slot) ?? resolveFromManifest(slot) ?? resolveFirstGguf();
+}
+function buildLoadArgsFromRegistryModel(model) {
+  const args = { modelPath: model.path };
+  const eliza1 = ELIZA_1_LOAD_METADATA[model.id];
+  if (eliza1) {
+    args.contextSize = eliza1.contextSize;
+    if (process.env.ELIZA_BIONIC_KV_QUANT?.trim() === "1") {
+      args.cacheTypeK = "qjl1_256";
+      args.cacheTypeV = "tbq3_0";
+    }
+    const mtpOverride = bionicMtpOverride();
+    const mtpEnabled = mtpOverride ?? eliza1.mtp !== void 0;
+    const drafterPath = eliza1.mtp ? resolveGemmaDrafterPath(model.path, eliza1.mtp.drafterFile) : null;
+    if (mtpEnabled && eliza1.mtp && drafterPath) {
+      args.draftModelPath = drafterPath;
+      args.draftMin = eliza1.mtp.draftMin;
+      args.draftMax = eliza1.mtp.draftMax;
+      args.mobileSpeculative = true;
+    }
+  }
+  return args;
+}
+function applyManifestLoadHints(args, entry) {
+  const contextSize = positiveInteger(entry.contextSize);
+  if (contextSize !== null) args.contextSize = contextSize;
+  if (typeof entry.useGpu === "boolean") args.useGpu = entry.useGpu;
+  const maxThreads = positiveInteger(entry.maxThreads);
+  if (maxThreads !== null) args.maxThreads = maxThreads;
+  const draftContextSize = positiveInteger(entry.draftContextSize);
+  if (draftContextSize !== null) args.draftContextSize = draftContextSize;
+  const draftMin = positiveInteger(entry.draftMin);
+  if (draftMin !== null) args.draftMin = draftMin;
+  const draftMax = positiveInteger(entry.draftMax);
+  if (draftMax !== null) args.draftMax = draftMax;
+  const speculativeSamples = positiveInteger(entry.speculativeSamples);
+  if (speculativeSamples !== null) {
+    args.speculativeSamples = speculativeSamples;
+  }
+  const draftModelPath = nonEmptyString(entry.draftModelPath);
+  if (draftModelPath) args.draftModelPath = draftModelPath;
+  const cacheTypeK = nonEmptyString(entry.cacheTypeK);
+  if (cacheTypeK) args.cacheTypeK = cacheTypeK;
+  const cacheTypeV = nonEmptyString(entry.cacheTypeV);
+  if (cacheTypeV) args.cacheTypeV = cacheTypeV;
+  if (typeof entry.mobileSpeculative === "boolean") {
+    args.mobileSpeculative = entry.mobileSpeculative;
+  }
+  if (typeof entry.disableThinking === "boolean") {
+    args.disableThinking = entry.disableThinking;
+  }
+  return args;
+}
+function buildLoadArgsFromManifestModel(model) {
+  const id = nonEmptyString(model.entry.id);
+  const args = id ? buildLoadArgsFromRegistryModel({ id, path: model.path }) : { modelPath: model.path };
+  return applyManifestLoadHints(args, model.entry);
+}
+function resolveLocalLoadArgs(slot) {
+  const envPath = resolveFromEnv(slot);
+  if (envPath) return { modelPath: envPath };
+  const registryModel = resolveAssignedRegistryModel(slot);
+  if (registryModel) return buildLoadArgsFromRegistryModel(registryModel);
+  const manifestModel = resolveManifestModel(slot);
+  if (manifestModel) return buildLoadArgsFromManifestModel(manifestModel);
+  const firstGguf = resolveFirstGguf();
+  return firstGguf ? { modelPath: firstGguf } : null;
+}
+var RECOMMENDED_MODELS = {
+  // The quantized 2B is the shipped mobile default. Both chat slots resolve
+  // to it — it is the entry tier, fits 8 GB-class phones with headroom, and is
+  // the model bundled into the AOSP image. The load path runs it at 64k
+  // context (see ELIZA_1_LOAD_METADATA) with compressed KV.
+  TEXT_SMALL: {
+    id: "eliza-1-2b",
+    hfRepo: "elizaos/eliza-1",
+    ggufFile: "bundles/2b/text/eliza-1-2b-128k.gguf",
+    localFile: "eliza-1-2b-128k.gguf"
+  },
+  TEXT_LARGE: {
+    id: "eliza-1-2b",
+    hfRepo: "elizaos/eliza-1",
+    ggufFile: "bundles/2b/text/eliza-1-2b-128k.gguf",
+    localFile: "eliza-1-2b-128k.gguf"
+  },
+  TEXT_EMBEDDING: {
+    id: "eliza-1-embedding",
+    hfRepo: "elizaos/eliza-1",
+    ggufFile: "bundles/4b/embedding/eliza-1-embedding.gguf",
+    localFile: "eliza-1-embedding.gguf"
+  }
+};
+var inflightDownloads = /* @__PURE__ */ new Map();
+function buildHfResolveUrl(model) {
+  const encodedPath = model.ggufFile.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+  return `https://huggingface.co/${model.hfRepo}/resolve/main/${encodedPath}?download=true`;
+}
+function buildRecommendedLoadArgs(slot, modelPath) {
+  const model = RECOMMENDED_MODELS[slot];
+  return buildLoadArgsFromRegistryModel({ id: model.id, path: modelPath });
+}
+async function downloadRecommendedModelFor(slot) {
+  const model = RECOMMENDED_MODELS[slot];
+  const dir = modelsDir();
+  mkdirSync(dir, { recursive: true });
+  const finalPath = path.join(
+    dir,
+    model.localFile ?? path.basename(model.ggufFile)
+  );
+  if (existsSync(finalPath)) {
+    const sz = statSync(finalPath).size;
+    if (!model.expectedSizeBytes || sz === model.expectedSizeBytes) {
+      return finalPath;
+    }
+    logger.warn(
+      `[mobile-device-bridge] ${model.ggufFile} present but size ${sz} != expected ${model.expectedSizeBytes}; re-downloading.`
+    );
+    try {
+      unlinkSync(finalPath);
+    } catch {
+    }
+  }
+  const dedupKey = model.id;
+  const existing = inflightDownloads.get(dedupKey);
+  if (existing) return existing;
+  const promise = (async () => {
+    const url = buildHfResolveUrl(model);
+    const stagingPath = `${finalPath}.part`;
+    try {
+      unlinkSync(stagingPath);
+    } catch {
+    }
+    logger.info(
+      `[mobile-device-bridge] Auto-downloading recommended ${slot} model ${model.id} from ${url}`
+    );
+    const response = await fetch(url, { redirect: "follow" });
+    if (!response.ok || !response.body) {
+      throw new Error(
+        `[mobile-device-bridge] Recommended-model download failed (${slot}): HTTP ${response.status} ${response.statusText} from ${url}`
+      );
+    }
+    await pipeline(
+      Readable.fromWeb(response.body),
+      createWriteStream(stagingPath)
+    );
+    const stagedSize = statSync(stagingPath).size;
+    if (model.expectedSizeBytes && stagedSize !== model.expectedSizeBytes) {
+      try {
+        unlinkSync(stagingPath);
+      } catch {
+      }
+      throw new Error(
+        `[mobile-device-bridge] Downloaded ${model.ggufFile} size ${stagedSize} != expected ${model.expectedSizeBytes}; aborting and removing partial file.`
+      );
+    }
+    renameSync(stagingPath, finalPath);
+    logger.info(
+      `[mobile-device-bridge] Auto-download complete: ${finalPath} (${stagedSize} bytes)`
+    );
+    return finalPath;
+  })();
+  inflightDownloads.set(dedupKey, promise);
+  try {
+    return await promise;
+  } finally {
+    inflightDownloads.delete(dedupKey);
+  }
+}
+async function resolveLoadArgsWithAutoDownload(slot) {
+  const existing = resolveLocalLoadArgs(slot);
+  if (existing) return existing;
+  if (process.env.ELIZA_DISABLE_MODEL_AUTO_DOWNLOAD?.trim() === "1") {
+    return null;
+  }
+  const downloaded = await downloadRecommendedModelFor(slot);
+  return buildRecommendedLoadArgs(slot, downloaded);
+}
+function resolveEmbeddingDimension() {
+  const assigned = resolveAssignedRegistryModel("TEXT_EMBEDDING");
+  return positiveInteger(process.env.ELIZA_LOCAL_EMBEDDING_DIMENSIONS) ?? positiveInteger(process.env.TEXT_EMBEDDING_DIMENSIONS) ?? positiveInteger(assigned?.dimensions) ?? positiveInteger(assigned?.embeddingDimension) ?? positiveInteger(assigned?.embeddingDimensions) ?? (assigned?.id ? KNOWN_EMBEDDING_DIMENSIONS[assigned.id] : null) ?? KNOWN_EMBEDDING_DIMENSIONS[RECOMMENDED_MODELS.TEXT_EMBEDDING.id] ?? 1024;
+}
+function flattenChatParamsForPrompt(params) {
+  if (typeof params.prompt === "string" && params.prompt.length > 0) {
+    return params.prompt;
+  }
+  const messages = params.messages ?? [];
+  const blocks = [];
+  const hasSystemMessage = messages.some(
+    (m) => m.role === "system"
+  );
+  if (!hasSystemMessage && typeof params.system === "string" && params.system) {
+    blocks.push(`system:
+${params.system}`);
+  }
+  for (const m of messages) {
+    const content = typeof m.content === "string" ? m.content : "";
+    if (!content) continue;
+    const role = (m.role ?? "user").toLowerCase();
+    const safeRole = role === "system" || role === "assistant" || role === "user" ? role : "user";
+    blocks.push(`${safeRole}:
+${content}`);
+  }
+  blocks.push("assistant:");
+  return blocks.join("\n\n");
+}
+var BIONIC_REQUEST_TIMEOUT_MS = readTimeoutMs(
+  "ELIZA_BIONIC_REQUEST_TIMEOUT_MS",
+  3e5
+);
+var BIONIC_MAX_FRAME_BYTES = 64 * 1024 * 1024;
+function bionicSocketName() {
+  if (process.env.ELIZA_BIONIC_HOST_DELEGATED?.trim() !== "1") return null;
+  const sock = process.env.ELIZA_BIONIC_INFERENCE_SOCK?.trim();
+  return sock ? sock : null;
+}
+function deriveBionicBundleDir(modelPath) {
+  if (!modelPath) return "";
+  const dir = path.dirname(modelPath);
+  if (path.basename(dir) === "text") return path.dirname(dir);
+  return "";
+}
+function roleForGemmaPrompt(role) {
+  if (role === "assistant") return "model";
+  if (role === "system") return "system";
+  return "user";
+}
+function collectChatMlPromptMessages(prompt, system) {
+  const headerPattern = /<\|im_start\|>(system|user|assistant)(?:\n|$)/g;
+  const headers = [];
+  let match = headerPattern.exec(prompt);
+  while (match !== null) {
+    headers.push({
+      index: match.index,
+      role: match[1],
+      bodyStart: match.index + match[0].length
+    });
+    match = headerPattern.exec(prompt);
+  }
+  if (headers.length === 0) return null;
+  const result = [];
+  if (system?.trim() && headers[0]?.role !== "system") {
+    result.push({ role: "system", content: system.trim() });
+  }
+  for (let i = 0; i < headers.length; i += 1) {
+    const current = headers[i];
+    const next = headers[i + 1];
+    const rawContent = prompt.slice(current.bodyStart, next ? next.index : prompt.length).replace(/<\|im_end\|>\s*$/g, "").trim();
+    if (!rawContent) continue;
+    result.push({ role: current.role, content: rawContent });
+  }
+  return result.length > 0 ? result : null;
+}
+function renderGemmaPromptMessages(messages) {
+  let out = "";
+  for (const m of messages) {
+    const content = m.content.trim();
+    if (!content) continue;
+    out += `<start_of_turn>${roleForGemmaPrompt(m.role)}
+${content}<end_of_turn>
+`;
+  }
+  return `${out}<start_of_turn>model
+`;
+}
+function buildGemmaBionicPrompt(params) {
+  const prompt = typeof params.prompt === "string" ? params.prompt : "";
+  const trimmedPrompt = prompt.trimEnd();
+  if (trimmedPrompt.includes("<start_of_turn>") && trimmedPrompt.includes("<start_of_turn>model")) {
+    return trimmedPrompt;
+  }
+  const msgs = prompt.includes("<|im_start|>") ? collectChatMlPromptMessages(prompt, params.system) : collectMessagesForNativeTemplate(params);
+  if (!msgs || msgs.length === 0) {
+    return `<start_of_turn>user
+${flattenChatParamsForPrompt(params).trim()}<end_of_turn>
+<start_of_turn>model
+`;
+  }
+  return renderGemmaPromptMessages(msgs);
+}
+function bionicHostGenerate(socketName, request) {
+  const payload = Buffer.from(JSON.stringify(request), "utf8");
+  const frame = Buffer.allocUnsafe(4 + payload.length);
+  frame.writeUInt32BE(payload.length, 0);
+  payload.copy(frame, 4);
+  return new Promise((resolve, reject) => {
+    const sock = net.connect({ path: `\0${socketName}` });
+    let settled = false;
+    let chunks = Buffer.alloc(0);
+    let expected = -1;
+    const finish = (err, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      sock.destroy();
+      err ? reject(err) : resolve(value);
+    };
+    const timer = setTimeout(
+      () => finish(new Error("[mobile-device-bridge] bionic host timed out")),
+      BIONIC_REQUEST_TIMEOUT_MS
+    );
+    sock.on("connect", () => sock.write(frame));
+    sock.on("data", (d) => {
+      chunks = Buffer.concat([chunks, d]);
+      if (expected < 0 && chunks.length >= 4) {
+        expected = chunks.readUInt32BE(0);
+        if (expected < 0 || expected > BIONIC_MAX_FRAME_BYTES) {
+          finish(
+            new Error(`[mobile-device-bridge] bad bionic frame ${expected}`)
+          );
+          return;
+        }
+      }
+      if (expected >= 0 && chunks.length >= 4 + expected) {
+        try {
+          finish(
+            null,
+            JSON.parse(chunks.subarray(4, 4 + expected).toString("utf8"))
+          );
+        } catch (e) {
+          finish(
+            new Error(
+              `[mobile-device-bridge] bad bionic JSON: ${e.message}`
+            )
+          );
+        }
+      }
+    });
+    sock.on(
+      "error",
+      (e) => finish(
+        new Error(`[mobile-device-bridge] bionic socket error: ${e.message}`)
+      )
+    );
+    sock.on("close", () => {
+      if (!settled)
+        finish(new Error("[mobile-device-bridge] bionic host closed early"));
+    });
+  });
+}
+function bionicHostGenerateStream(socketName, request, onToken) {
+  const payload = Buffer.from(
+    JSON.stringify({ ...request, op: "generateStream" }),
+    "utf8"
+  );
+  const frame = Buffer.allocUnsafe(4 + payload.length);
+  frame.writeUInt32BE(payload.length, 0);
+  payload.copy(frame, 4);
+  return new Promise((resolve, reject) => {
+    const sock = net.connect({ path: `\0${socketName}` });
+    let settled = false;
+    let chunks = Buffer.alloc(0);
+    const finish = (err, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      sock.destroy();
+      err ? reject(err) : resolve(value);
+    };
+    const timer = setTimeout(
+      () => finish(new Error("[mobile-device-bridge] bionic host timed out")),
+      BIONIC_REQUEST_TIMEOUT_MS
+    );
+    sock.on("connect", () => sock.write(frame));
+    sock.on("data", (d) => {
+      chunks = Buffer.concat([chunks, d]);
+      for (; ; ) {
+        if (chunks.length < 4) break;
+        const expected = chunks.readUInt32BE(0);
+        if (expected < 0 || expected > BIONIC_MAX_FRAME_BYTES) {
+          finish(
+            new Error(`[mobile-device-bridge] bad bionic frame ${expected}`)
+          );
+          return;
+        }
+        if (chunks.length < 4 + expected) break;
+        const json = chunks.subarray(4, 4 + expected).toString("utf8");
+        chunks = chunks.subarray(4 + expected);
+        let msg;
+        try {
+          msg = JSON.parse(json);
+        } catch (e) {
+          finish(
+            new Error(
+              `[mobile-device-bridge] bad bionic JSON: ${e.message}`
+            )
+          );
+          return;
+        }
+        if (msg.type === "token") {
+          if (typeof msg.text === "string" && msg.text) onToken(msg.text);
+          continue;
+        }
+        finish(null, msg);
+        return;
+      }
+    });
+    sock.on(
+      "error",
+      (e) => finish(
+        new Error(`[mobile-device-bridge] bionic socket error: ${e.message}`)
+      )
+    );
+    sock.on("close", () => {
+      if (!settled)
+        finish(new Error("[mobile-device-bridge] bionic host closed early"));
+    });
+  });
+}
+function makeGenerateHandler(slot) {
+  return async (_runtime, params) => {
+    const bionicSock = bionicSocketName();
+    if (bionicSock) {
+      const installed = resolveLocalLoadArgs(slot);
+      const baseRequest = {
+        bundleDir: installed ? deriveBionicBundleDir(installed.modelPath) : "",
+        drafterPath: installed?.draftModelPath ?? "",
+        prompt: buildGemmaBionicPrompt(params),
+        maxTokens: params.maxTokens ?? 256
+      };
+      const onChunk = params.onStreamChunk;
+      let accumulated = "";
+      const res = typeof onChunk === "function" ? await bionicHostGenerateStream(bionicSock, baseRequest, (text) => {
+        accumulated += text;
+        void onChunk(text, void 0, accumulated);
+      }) : await bionicHostGenerate(bionicSock, {
+        op: "generate",
+        ...baseRequest
+      });
+      if (!res.ok) {
+        throw new Error(
+          `[mobile-device-bridge] bionic host generate failed: ${res.error ?? "unknown"}`
+        );
+      }
+      if (typeof res.tokS === "number") {
+        logger.info(
+          `[mobile-device-bridge] bionic GPU generate: ${res.tokens ?? "?"} tok @ ${res.tokS.toFixed(1)} tok/s`
+        );
+      }
+      return res.text ?? "";
+    }
+    const loadArgs = await resolveLoadArgsWithAutoDownload(slot);
+    if (!loadArgs) {
+      throw new Error(
+        `[mobile-device-bridge] No local GGUF model installed under ${modelsDir()} and auto-download is disabled (ELIZA_DISABLE_MODEL_AUTO_DOWNLOAD=1). Install a model or unset the disable flag.`
+      );
+    }
+    await mobileDeviceBridge.loadModel(loadArgs);
+    const messagesForTemplate = collectMessagesForNativeTemplate(params);
+    let nativePrompt = null;
+    if (messagesForTemplate) {
+      try {
+        nativePrompt = await mobileDeviceBridge.formatChat(messagesForTemplate);
+      } catch (err) {
+        logger.warn(
+          `[mobile-device-bridge] getFormattedChat failed, falling back to plain-text flatten: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    const prompt = nativePrompt ?? flattenChatParamsForPrompt(params);
+    return mobileDeviceBridge.generate({
+      prompt,
+      stopSequences: params.stopSequences,
+      maxTokens: params.maxTokens,
+      temperature: params.temperature
+    });
+  };
+}
+function collectMessagesForNativeTemplate(params) {
+  const messages = params.messages ?? [];
+  if (messages.length === 0 && typeof params.prompt === "string") {
+    return collectRoleLabeledPromptMessages(params.prompt, params.system);
+  }
+  const result = [];
+  const hasSystemMessage = messages.some(
+    (m) => m.role === "system"
+  );
+  if (!hasSystemMessage && typeof params.system === "string" && params.system) {
+    result.push({ role: "system", content: params.system });
+  }
+  for (const m of messages) {
+    const content = typeof m.content === "string" ? m.content : "";
+    if (!content) continue;
+    const role = (m.role ?? "user").toLowerCase();
+    const safeRole = role === "system" || role === "assistant" || role === "user" ? role : "user";
+    result.push({ role: safeRole, content });
+  }
+  return result.length > 0 ? result : null;
+}
+function collectRoleLabeledPromptMessages(prompt, system) {
+  if (!/^(system|user|assistant):\n/.test(prompt)) return null;
+  const headerPattern = /(^|\n{2,})(system|user|assistant):\n/g;
+  const headers = [];
+  let match = headerPattern.exec(prompt);
+  while (match !== null) {
+    headers.push({
+      index: match.index,
+      role: match[2],
+      bodyStart: match.index + match[0].length
+    });
+    match = headerPattern.exec(prompt);
+  }
+  if (headers.length === 0) return null;
+  const result = [];
+  if (system?.trim() && headers[0]?.role !== "system") {
+    result.push({ role: "system", content: system.trim() });
+  }
+  for (let i = 0; i < headers.length; i += 1) {
+    const current = headers[i];
+    const next = headers[i + 1];
+    const rawContent = prompt.slice(current.bodyStart, next ? next.index : prompt.length).trim();
+    if (!rawContent) continue;
+    result.push({ role: current.role, content: rawContent });
+  }
+  return result.length > 0 ? result : null;
+}
+function extractEmbeddingText(params) {
+  if (params === null) return "";
+  if (typeof params === "string") return params;
+  return params.text;
+}
+function makeEmbeddingHandler() {
+  return async (_runtime, params) => {
+    if (params === null) {
+      return new Array(resolveEmbeddingDimension()).fill(0);
+    }
+    let loadArgs = resolveLocalLoadArgs("TEXT_EMBEDDING");
+    let modelPath = loadArgs?.modelPath ?? null;
+    if (!modelPath) {
+      if (process.env.ELIZA_DISABLE_MODEL_AUTO_DOWNLOAD?.trim() === "1") {
+        throw new Error(
+          `[mobile-device-bridge] No local GGUF embedding model installed under ${modelsDir()} and auto-download is disabled.`
+        );
+      }
+      modelPath = await downloadRecommendedModelFor("TEXT_EMBEDDING");
+      loadArgs = buildRecommendedLoadArgs("TEXT_EMBEDDING", modelPath);
+    }
+    if (!loadArgs) {
+      throw new Error(
+        `[mobile-device-bridge] No local GGUF embedding model resolved for ${modelsDir()}.`
+      );
+    }
+    const bionicSock = bionicSocketName();
+    if (bionicSock) {
+      const res = await bionicHostGenerate(bionicSock, {
+        op: "embed",
+        bundleDir: deriveBionicBundleDir(loadArgs.modelPath),
+        text: extractEmbeddingText(params)
+      });
+      if (!res.ok || !Array.isArray(res.embedding)) {
+        throw new Error(
+          `[mobile-device-bridge] bionic embed failed: ${res.error ?? "no embedding"}`
+        );
+      }
+      return res.embedding;
+    }
+    await mobileDeviceBridge.loadModel(loadArgs);
+    return mobileDeviceBridge.embed({
+      input: extractEmbeddingText(params)
+    });
+  };
+}
+function getMobileDeviceBridgeStatus() {
+  return mobileDeviceBridge.status();
+}
+async function loadMobileDeviceBridgeModel(modelPath, modelId) {
+  await mobileDeviceBridge.loadModel(
+    modelId ? buildLoadArgsFromRegistryModel({ id: modelId, path: modelPath }) : { modelPath }
+  );
+}
+async function unloadMobileDeviceBridgeModel() {
+  await mobileDeviceBridge.unloadModel();
+}
+async function attachMobileDeviceBridgeToServer(server) {
+  await mobileDeviceBridge.attachToHttpServer(server);
+}
+async function imageUrlToBase64(url) {
+  if (url.startsWith("data:")) {
+    const comma = url.indexOf(",");
+    return comma >= 0 ? url.slice(comma + 1) : url;
+  }
+  const resp = await fetch(url);
+  if (!resp.ok) {
+    throw new Error(
+      `[mobile-device-bridge] IMAGE_DESCRIPTION failed to fetch ${url}: ${resp.status}`
+    );
+  }
+  return Buffer.from(await resp.arrayBuffer()).toString("base64");
+}
+function collapseDescriptionRepetition(text) {
+  const sentences = text.replace(/\s+/g, " ").split(/(?<=[.!?])\s+/).map((s) => s.trim()).filter(Boolean);
+  const seen = /* @__PURE__ */ new Set();
+  const kept = [];
+  for (const sentence of sentences) {
+    const key = sentence.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+    if (key && seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    kept.push(sentence);
+    if (kept.length >= 6) {
+      break;
+    }
+  }
+  return kept.join(" ").trim() || text.trim();
+}
+function makeBionicImageDescriptionHandler() {
+  return async (_runtime, params) => {
+    const socketName = bionicSocketName();
+    if (!socketName) {
+      throw new Error(
+        "[mobile-device-bridge] IMAGE_DESCRIPTION requires the bionic host (ELIZA_BIONIC_HOST_DELEGATED=1)"
+      );
+    }
+    const url = typeof params === "string" ? params : params?.imageUrl;
+    if (typeof url !== "string" || url.length === 0) {
+      throw new Error(
+        "[mobile-device-bridge] IMAGE_DESCRIPTION requires a non-empty imageUrl"
+      );
+    }
+    const prompt = typeof params === "object" && params ? params.prompt : void 0;
+    const imageBase64 = await imageUrlToBase64(url);
+    const res = await bionicHostGenerate(socketName, {
+      op: "image",
+      bundleDir: "",
+      imageBase64,
+      mmprojPath: "",
+      prompt: prompt ?? ""
+    });
+    if (!res.ok) {
+      throw new Error(
+        `[mobile-device-bridge] bionic image describe failed: ${res.error ?? "unknown error"}`
+      );
+    }
+    const raw = (res.text ?? "").trim();
+    if (!raw) {
+      throw new Error(
+        "[mobile-device-bridge] bionic image describe returned empty text"
+      );
+    }
+    const description = collapseDescriptionRepetition(raw);
+    return {
+      title: description.split(/[.!?]/, 1)[0]?.trim() || "Image",
+      description
+    };
+  };
+}
+async function ensureMobileDeviceBridgeInferenceHandlers(runtime) {
+  logger.debug("[mobile-device-bridge] Bootstrap entered");
+  if (!SERVICE_ENABLED || process.env.ELIZA_LOCAL_LLAMA?.trim() === "1") {
+    logger.debug("[mobile-device-bridge] Disabled or AOSP local llama active");
+    return false;
+  }
+  if (registeredRuntimes.has(runtime)) {
+    logger.debug("[mobile-device-bridge] Handlers already registered");
+    return true;
+  }
+  const runtimeWithRegistration = runtime;
+  if (typeof runtimeWithRegistration.getModel !== "function" || typeof runtimeWithRegistration.registerModel !== "function") {
+    logger.error(
+      "[mobile-device-bridge] Runtime is missing getModel/registerModel; cannot wire handlers."
+    );
+    return false;
+  }
+  runtimeWithRegistration.registerModel(
+    ModelType.TEXT_SMALL,
+    makeGenerateHandler("TEXT_SMALL"),
+    PROVIDER,
+    LOCAL_INFERENCE_PRIORITY
+  );
+  runtimeWithRegistration.registerModel(
+    ModelType.TEXT_LARGE,
+    makeGenerateHandler("TEXT_LARGE"),
+    PROVIDER,
+    LOCAL_INFERENCE_PRIORITY
+  );
+  if (!resolveLocalLoadArgs("TEXT_SMALL") && process.env.ELIZA_DISABLE_MODEL_AUTO_DOWNLOAD?.trim() !== "1") {
+    downloadRecommendedModelFor("TEXT_SMALL").catch(
+      (err) => logger.warn(
+        `[mobile-device-bridge] Background chat-model download failed: ${err.message}`
+      )
+    );
+  }
+  runtimeWithRegistration.registerModel(
+    ModelType.TEXT_EMBEDDING,
+    makeEmbeddingHandler(),
+    PROVIDER,
+    LOCAL_INFERENCE_PRIORITY
+  );
+  if (bionicSocketName()) {
+    runtimeWithRegistration.registerModel(
+      ModelType.IMAGE_DESCRIPTION,
+      makeBionicImageDescriptionHandler(),
+      PROVIDER,
+      LOCAL_INFERENCE_PRIORITY
+    );
+    logger.info(
+      "[mobile-device-bridge] Registered bionic IMAGE_DESCRIPTION handler (op=image)"
+    );
+  }
+  const embeddingModelPath = resolveLocalModelPath("TEXT_EMBEDDING");
+  if (!embeddingModelPath && process.env.ELIZA_DISABLE_MODEL_AUTO_DOWNLOAD?.trim() !== "1") {
+    downloadRecommendedModelFor("TEXT_EMBEDDING").catch(
+      (err) => logger.warn(
+        `[mobile-device-bridge] Background embedding-model download failed: ${err.message}`
+      )
+    );
+  }
+  logger.info(
+    `[mobile-device-bridge] Registered ${PROVIDER} handlers for TEXT_SMALL / TEXT_LARGE${embeddingModelPath ? " / TEXT_EMBEDDING" : ""} at priority ${LOCAL_INFERENCE_PRIORITY}`
+  );
+  registeredRuntimes.add(runtime);
+  return true;
+}
+
+export {
+  mobileDeviceBridge,
+  buildLoadArgsFromRegistryModel,
+  buildGemmaBionicPrompt,
+  getMobileDeviceBridgeStatus,
+  loadMobileDeviceBridgeModel,
+  unloadMobileDeviceBridgeModel,
+  attachMobileDeviceBridgeToServer,
+  ensureMobileDeviceBridgeInferenceHandlers
+};