offgrid-ai 0.15.9 → 0.16.3

package/src/omlx-runtime.mjs

@@ -0,0 +1,232 @@
+// oMLX runtime management — discovery, version checking, update prompts,
+// and installation. Mirrors the llama.cpp runtime pattern in runtime.mjs.
+//
+// oMLX is installed either via the macOS app (DMG from GitHub Releases, which
+// installs a ~/.omlx/bin/omlx CLI shim with in-app auto-update) or via Homebrew
+// (brew tap jundot/omlx && brew install omlx). offgrid-ai does NOT download
+// binaries directly — it uses brew for automated installs, and prompts for the
+// DMG when brew is unavailable.
+
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { compareVersions } from "./updates.mjs";
+import { hasHomebrew, ensureHomebrewFor } from "./config.mjs";
+import { commandExists } from "./exec.mjs";
+import { pc, renderCard, renderRows } from "./ui.mjs";
+
+const execFileAsync = promisify(execFile);
+
+const OMLX_CLI_SHIM = join(homedir(), ".omlx", "bin", "omlx");
+const RELEASE_API = "https://api.github.com/repos/jundot/omlx/releases/latest";
+
+// ── Discovery ──────────────────────────────────────────────────────────────
+
+/**
+ * Find the oMLX CLI binary. Checks the app-installed shim first (it shadows
+ * brew on PATH), then falls back to PATH. Returns the path or null.
+ */
+export async function findOmlx() {
+  // 1. macOS app CLI shim (shadows brew on PATH)
+  if (existsSync(OMLX_CLI_SHIM)) return OMLX_CLI_SHIM;
+
+  // 2. PATH (brew install)
+  try {
+    const { stdout } = await execFileAsync("which", ["omlx"]);
+    const path = stdout.trim();
+    if (path && existsSync(path)) return path;
+  } catch { /* not on PATH */ }
+
+  return null;
+}
+
+/**
+ * Check if oMLX is installed (app shim or on PATH).
+ */
+export async function hasOmlx() {
+  return (await findOmlx()) !== null;
+}
+
+/**
+ * Detect how oMLX was installed: "app" (macOS app CLI shim) or "brew" (on PATH
+ * but not the shim) or null (not installed).
+ */
+export async function omlxInstallMethod() {
+  if (existsSync(OMLX_CLI_SHIM)) return "app";
+  if (await commandExists("omlx")) return "brew";
+  return null;
+}
+
+// ── Version checking ───────────────────────────────────────────────────────
+
+/**
+ * Get the installed oMLX version by running `omlx --version`.
+ * Returns null if oMLX is not installed or the version can't be parsed.
+ */
+export async function installedOmlxVersion() {
+  const bin = await findOmlx();
+  if (!bin) return null;
+  try {
+    const { stdout } = await execFileAsync(bin, ["--version"], { timeout: 5000 });
+    const match = stdout.trim().match(/(\d+\.\d+\.\d+)/u);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check for the latest oMLX release on GitHub.
+ * Returns { tag, version } or null if the check fails.
+ * Callers must treat null as "check failed, skip prompt".
+ */
+export async function latestOmlxRelease(fetchImpl = globalThis.fetch) {
+  try {
+    const response = await fetchImpl(RELEASE_API, { signal: AbortSignal.timeout(5000) });
+    if (!response.ok) return null;
+    const body = await response.json();
+    const tag = typeof body?.tag_name === "string" ? body.tag_name : null;
+    if (!tag) return null;
+    const version = tag.replace(/^v/u, "");
+    return { tag, version };
+  } catch {
+    return null;
+  }
+}
+
+// ── Update prompt ──────────────────────────────────────────────────────────
+
+/**
+ * Check if an oMLX update is available and offer to install it.
+ * Returns true if an update was installed, false otherwise.
+ *
+ * For brew installs: runs `brew upgrade omlx`.
+ * For app installs: the app has in-app auto-update, so we just inform the user.
+ */
+export async function offerManagedOmlxUpdate(prompt, { fetchImpl = globalThis.fetch } = {}) {
+  const latest = await latestOmlxRelease(fetchImpl);
+  if (!latest) return false;
+
+  const installed = await installedOmlxVersion();
+  if (installed && compareVersions(installed, latest.version) >= 0) return false;
+
+  const method = await omlxInstallMethod();
+
+  console.log("\n" + renderCard("oMLX runtime", renderRows([
+    ["Installed", installed ?? pc.yellow("not installed")],
+    ["Latest", pc.green(latest.version)],
+    ["Source", method === "app" ? "macOS app (in-app auto-update)" : "Homebrew"],
+  ]), { formatBorder: pc.cyan }));
+
+  // App installs have their own auto-update — just inform the user
+  if (method === "app" && installed) {
+    console.log(pc.dim("  Update oMLX via the app's in-app updater, then restart offgrid-ai."));
+    return false;
+  }
+
+  // Not installed, or brew install — offer to install/upgrade
+  if (!installed) {
+    const shouldInstall = await prompt.yesNo("Install oMLX runtime?", false);
+    if (!shouldInstall) return false;
+    return await installOmlx(prompt);
+  }
+
+  // Brew install with an update available
+  const shouldUpdate = await prompt.yesNo("Update oMLX runtime?", false);
+  if (!shouldUpdate) return false;
+
+  try {
+    const { runCommand } = await import("./exec.mjs");
+    console.log(pc.dim("Updating oMLX via Homebrew..."));
+    await runCommand("brew", ["update"], { label: "brew update" });
+    await runCommand("brew", ["upgrade", "omlx"], { label: "brew upgrade omlx" });
+    console.log(pc.green(`✓ Updated oMLX to latest`));
+    return true;
+  } catch (err) {
+    console.log(pc.red(`✗ Update failed: ${err.message}`));
+    console.log(pc.dim("Update manually: brew update && brew upgrade omlx"));
+    return false;
+  }
+}
+
+// ── Installation ───────────────────────────────────────────────────────────
+
+/**
+ * Install oMLX. Uses Homebrew if available (automating tap + install).
+ * If Homebrew is not available, prompts to download the DMG from GitHub
+ * Releases or install Homebrew first.
+ *
+ * @param {object} prompt - UI prompt interface (yesNo, choice)
+ * @param {function} [run] - runCommand function for verbose command execution
+ * @returns {Promise<boolean>} true if installation succeeded
+ */
+export async function installOmlx(prompt, run) {
+  const hasBrew = await hasHomebrew();
+
+  if (!hasBrew) {
+    if (!(await ensureHomebrewFor(prompt, run || (async (cmd, args, label) => {
+      const { runCommand } = await import("./exec.mjs");
+      return runCommand(cmd, args, { label });
+    }), "oMLX"))) {
+      console.log(pc.dim("Install oMLX manually:"));
+      console.log(pc.dim("  brew tap jundot/omlx && brew install omlx"));
+      console.log(pc.dim("  — or download the macOS app from https://github.com/jundot/omlx/releases"));
+      return false;
+    }
+  }
+
+  // Install oMLX via Homebrew
+  const runner = run || (async (cmd, args, label) => {
+    const { runCommand } = await import("./exec.mjs");
+    return runCommand(cmd, args, { label });
+  });
+
+  console.log(pc.cyan("Installing oMLX via Homebrew..."));
+  try {
+    await runner("brew", ["tap", "jundot/omlx", "https://github.com/jundot/omlx"], "oMLX tap");
+    await runner("brew", ["install", "omlx"], "oMLX");
+    console.log(pc.green("✓ oMLX installed"));
+    return true;
+  } catch (err) {
+    console.log(pc.red(`✗ oMLX installation failed: ${err.message}`));
+    console.log(pc.dim("Install manually: brew tap jundot/omlx && brew install omlx"));
+    console.log(pc.dim("  — or download the macOS app from https://github.com/jundot/omlx/releases"));
+    return false;
+  }
+}
+
+/**
+ * Ensure oMLX runtime is available. For onboarding: if not installed, offer
+ * to install it. This is the oMLX equivalent of ensureLlamaRuntime().
+ *
+ * @param {object} prompt - UI prompt interface
+ * @param {function} [run] - runCommand function for verbose output
+ * @returns {Promise<boolean>} true if oMLX is available (installed or pre-existing)
+ */
+export async function ensureOmlxRuntime(prompt, run) {
+  let omlxBin = await findOmlx();
+  if (!omlxBin) {
+    console.log(renderCard("oMLX runtime", renderRows([
+      ["Status", pc.yellow("not installed")],
+      ["Used for", "local MLX models (Apple Silicon optimized)"],
+      ["Install", "managed by offgrid-ai via Homebrew"],
+    ]), { formatBorder: pc.cyan }));
+
+    const shouldInstall = await prompt.yesNo("Install oMLX runtime?", true);
+    if (shouldInstall) {
+      await installOmlx(prompt, run);
+      omlxBin = await findOmlx();
+    }
+
+    if (!omlxBin) {
+      console.log(pc.yellow("Skipping oMLX for now. You can still use llama.cpp, or run offgrid-ai again to install."));
+      return false;
+    }
+  }
+
+  const version = await installedOmlxVersion();
+  console.log(pc.green(`✓ oMLX: ${omlxBin}${version ? ` (v${version})` : ""}`));
+  return true;
+}

package/src/process.mjs

@@ -6,6 +6,7 @@ import { basename, join } from "node:path";
 import { LOG_DIR } from "./config.mjs";
 import { writeState, readState, profileDir } from "./profiles.mjs";
 import { backendFor, backendBinaryFor } from "./backends.mjs";
+import { pc } from "./ui.mjs";
 
 const execFileAsync = promisify(execFile);
 
@@ -21,32 +22,17 @@ export async function computeServerCommand(profile) {
   const binary = await backendBinaryFor(profile.backend);
   if (!binary) throw new Error("Server binary not found. Run offgrid-ai interactively to install.");
 
-  let argv, extraEnv;
-
-  if (profile.backend === "mlx-vlm") {
-    const { computeMlxVlmFlags } = await import("./mlx-flags.mjs");
-    const result = computeMlxVlmFlags(profile.modelPath, {
-      port: profile.flags?.port,
-      ctxSize: profile.flags?.ctxSize,
-      thinkingEnabled: profile.capabilities?.thinking ?? true,
-    });
-    argv = result.args;
-    extraEnv = { APC_ENABLED: "1", MLX_VLM_MAX_TOKENS: "16384" };
-  } else {
-    // llama-cpp / llama-cpp-mtp
-    const { computeFlags } = await import("./autodetect.mjs");
-    const result = computeFlags(
-      profile.capabilities ?? {},
-      profile.modelPath,
-      profile.mmprojPath,
-      profile.drafterPath,
-      profile.flags ?? {},
-    );
-    argv = result.argv;
-    extraEnv = {};
-  }
+  // llama-cpp
+  const { computeFlags } = await import("./autodetect.mjs");
+  const result = computeFlags(
+    profile.capabilities ?? {},
+    profile.modelPath,
+    profile.mmprojPath,
+    profile.drafterPath,
+    profile.flags ?? {},
+  );
 
-  return { binary, argv, extraEnv, backend };
+  return { binary, argv: result.argv, extraEnv: {}, backend };
 }
 
 /** Build a runnable start.sh script for the profile. */
@@ -132,19 +118,83 @@ async function startLocalServer(profile) {
 }
 
 async function startManagedServer(profile, backend) {
-  const ready = await serverReady(profile.baseUrl);
-  if (ready) {
-    // Already running
-  } else {
-    for (let i = 0; i < 60; i++) {
-      await sleep(2000);
-      if (await serverReady(profile.baseUrl)) break;
-      process.stdout.write(".");
+  if (await serverReady(profile.baseUrl)) {
+    // Apply per-model settings (MTP) even when server is already running.
+    if (backend.id === "omlx" && profile.capabilities?.mtp) {
+      await ensureOmlxMtpSetting(profile);
     }
-    if (!(await serverReady(profile.baseUrl))) {
-      throw new Error(`${backend.label} is not responding at ${profile.baseUrl}. Start it and try again.`);
+    return writeManagedState(profile, backend);
+  }
+
+  // Try to start the managed server via CLI
+  if (backend.id === "omlx") {
+    try {
+      const { execFile } = await import("node:child_process");
+      const { promisify } = await import("node:util");
+      const { findOmlx } = await import("./omlx-runtime.mjs");
+      const omlxBin = await findOmlx();
+      if (!omlxBin) {
+        throw new Error(`${backend.label} is not installed. Run offgrid-ai to install it, or install manually: brew tap jundot/omlx && brew install omlx`);
+      }
+      await promisify(execFile)(omlxBin, ["start"], { timeout: 10000 });
+    } catch (err) {
+      if (err.message.includes("not installed")) throw err;
+      throw new Error(`${backend.label} could not be auto-started: ${err.message}. Run \`omlx start\` manually.`, { cause: err });
     }
   }
+
+  // Wait for it to come up
+  for (let i = 0; i < 60; i++) {
+    await sleep(2000);
+    if (await serverReady(profile.baseUrl)) break;
+    process.stdout.write(".");
+  }
+  if (!(await serverReady(profile.baseUrl))) {
+    throw new Error(`${backend.label} is not responding at ${profile.baseUrl}. Start it and try again.`);
+  }
+
+  // Apply per-model settings (MTP) before the model is loaded.
+  // oMLX applies MTP patches at load time, so the setting must be in
+  // model_settings.json before any request triggers a load.
+  if (backend.id === "omlx" && profile.capabilities?.mtp) {
+    await ensureOmlxMtpSetting(profile);
+  }
+
+  return writeManagedState(profile, backend);
+}
+
+/**
+ * Enable MTP on an oMLX model via the admin API before loading.
+ * oMLX applies MTP patches at model load time, so the setting must be
+ * persisted to model_settings.json before any request triggers a load.
+ * If the model is already loaded, oMLX will use the setting on next reload.
+ */
+async function ensureOmlxMtpSetting(profile) {
+  const baseUrl = profile.baseUrl?.replace(/\/v1\/?$/u, "") || "";
+  const modelId = profile.omlxModel ?? profile.modelAlias ?? profile.id;
+  try {
+    const response = await fetch(`${baseUrl}/admin/api/models/${encodeURIComponent(modelId)}/settings`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ mtp_enabled: true }),
+      signal: AbortSignal.timeout(5000),
+    });
+    if (response.ok) {
+      console.log(pc.green(`[mtp] Enabled MTP speculative decoding for ${modelId}`));
+    } else if (response.status === 401 || response.status === 403) {
+      console.log(pc.yellow(`[mtp] Could not enable MTP: oMLX admin authentication required. Enable skip_api_key_verification in oMLX settings, or enable MTP manually from the admin panel.`));
+    } else if (response.status === 404) {
+      console.log(pc.yellow(`[mtp] Model ${modelId} not found on oMLX server. MTP setting not applied.`));
+    } else {
+      const detail = await response.text().catch(() => "");
+      console.log(pc.yellow(`[mtp] Could not enable MTP: HTTP ${response.status} ${detail}`));
+    }
+  } catch (err) {
+    console.log(pc.yellow(`[mtp] Could not enable MTP: ${err.message}`));
+  }
+}
+
+async function writeManagedState(profile, backend) {
   const state = {
     pid: null,
     profileId: profile.id,
@@ -180,10 +230,7 @@ export async function stopProfile(profile) {
 }
 
 // Reliably terminate a detached local-server process group: SIGTERM with a
-// grace period for graceful shutdown (lets mlx-vlm/llama-server release the
-// model), then SIGKILL if still alive. Guarantees the model is unloaded when a
-// profile stops — consistent across backends (llama-server exits on SIGTERM;
-// mlx-vlm/uvicorn often does not, hence the SIGKILL fallback).
+// grace period for graceful shutdown, then SIGKILL if still alive.
 async function terminateProcess(pid) {
   const signalGroup = (sig) => {
     try { process.kill(-pid, sig); }
@@ -226,9 +273,7 @@ async function processGone(pid) {
 export async function unloadModelFromServer(profile) {
   const backend = backendFor(profile.backend);
 
-  if (backend.id === "llama-cpp" || backend.id === "llama-cpp-mtp") {
-    // llama.cpp unloads when the server process exits; no HTTP unload API exists.
-    // If offgrid-ai started the server, stopProfile already handled it.
+  if (backend.id === "llama-cpp") {
     return { unloaded: false, backend: backend.id, reason: "stop server to unload" };
   }
 
@@ -236,12 +281,6 @@ export async function unloadModelFromServer(profile) {
     return await unloadOmlxModel(profile);
   }
 
-  if (backend.id === "mlx-vlm") {
-    // mlx-vlm is a local-server backend — stopProfile handles unload by killing
-    // the process. No HTTP unload API.
-    return { unloaded: false, backend: backend.id, reason: "stop server to unload" };
-  }
-
   return { unloaded: false, backend: backend.id, reason: "unsupported backend" };
 }
 

package/src/profile-setup.mjs

@@ -3,13 +3,13 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { estimateMemory } from "./estimate.mjs";
 import { findLlamaServer } from "./config.mjs";
-import { baseUrlForFlags, LLAMA_CPP_PORT, LLAMA_CPP_MTP_PORT } from "./backends.mjs";
+import { baseUrlForFlags } from "./backends.mjs";
 import { pc, formatBytes, renderRows, renderSection } from "./ui.mjs";
 import { detectCapabilities } from "./autodetect.mjs";
 import { matchDrafter } from "./scan.mjs";
 import { scanGgufModels } from "./scan.mjs";
-import { estimateMemoryMb } from "./mlx-flags.mjs";
 import { capabilitySummary } from "./model-summary.mjs";
+import { detectOmlxMtpCapability, findOmlxModelDir } from "./mlx-discovery.mjs";
 
 const execFileAsync = promisify(execFile);
 
@@ -50,19 +50,9 @@ export async function configureLocalProfile(prompt, profile) {
   }
   const hasMtp = freshCaps.mtp || Boolean(drafterPath);
   const caps = { ...freshCaps, mtp: hasMtp };
-  // If MTP is newly available, switch backend and add drafter path
-  if (hasMtp && configured.backend !== "llama-cpp-mtp") {
-    configured = { ...configured, backend: "llama-cpp-mtp", providerId: "llama-cpp-mtp", drafterPath, capabilities: { ...configured.capabilities, mtp: true } };
-  }
-  // If the profile was MTP but the drafter is now gone (and the model isn't
-  // natively MTP), switch back to plain llama.cpp so the server can start.
-  if (!hasMtp && configured.backend === "llama-cpp-mtp") {
-    console.log(pc.yellow("MTP drafter no longer found — switching to llama.cpp without speculative decoding."));
-    configured = removeMtpDefaults(configured);
-  }
-  if (drafterPath && !configured.drafterPath) {
-    configured = { ...configured, drafterPath };
-  }
+  // MTP is a capability, not a separate backend. Just update the profile's
+  // capabilities and drafter path — flag computation handles the rest.
+  configured = { ...configured, drafterPath: drafterPath ?? null, capabilities: { ...configured.capabilities, mtp: hasMtp } };
   // If vision was previously disabled but mmproj is back, re-enable
   if (configured.disabledMmprojPath && configured.mmprojPath === null && freshCaps.vision) {
     configured = { ...configured, mmprojPath: configured.disabledMmprojPath, disabledMmprojPath: undefined, capabilities: { ...configured.capabilities, vision: true, visionDisabledReason: undefined } };
@@ -82,8 +72,7 @@ export async function configureLocalProfile(prompt, profile) {
   if (caps.mtp) {
     const drafterInfo = configured.drafterPath ? `\n  Drafter: ${configured.drafterPath}` : "";
     console.log(renderSection("MTP detected", renderRows([
-      ["Backend", "llama.cpp MTP"],
-      ["Port", String(LLAMA_CPP_MTP_PORT)],
+      ["Feature", "Multi-Token Prediction (speculative decoding)"],
       ["Flags", `--spec-type draft-mtp --spec-draft-n-max 4${configured.drafterPath ? " --spec-draft-model <drafter>" : ""}`],
     ])));
     if (drafterInfo) console.log(pc.dim(drafterInfo));
@@ -151,24 +140,60 @@ export function applyRuntimeFlagOverrides(profile, overrides) {
 }
 
 export function applyMtpDefaults(profile) {
-  const flags = { ...profile.flags, port: LLAMA_CPP_MTP_PORT };
   return applyProfileFlags({
     ...profile,
-    backend: "llama-cpp-mtp",
-    providerId: "llama-cpp-mtp",
     capabilities: { ...(profile.capabilities ?? {}), mtp: true },
-  }, flags);
+  }, profile.flags);
 }
 
 export function removeMtpDefaults(profile) {
-  const flags = { ...profile.flags, port: LLAMA_CPP_PORT };
   return applyProfileFlags({
     ...profile,
-    backend: "llama-cpp",
-    providerId: "llama-cpp",
     drafterPath: null,
     capabilities: { ...(profile.capabilities ?? {}), mtp: false },
-  }, flags);
+  }, profile.flags);
+}
+
+// ── oMLX (managed server) profile configuration ───────────────────────────
+
+export async function configureManagedProfile(prompt, profile) {
+  let configured = profile;
+  const modelId = profile.omlxModel ?? profile.modelAlias ?? profile.id;
+
+  // Detect MTP capability from the model's config.json
+  const modelDir = await findOmlxModelDir(modelId);
+  if (modelDir) {
+    const mtpResult = await detectOmlxMtpCapability(modelDir);
+    if (mtpResult.compatible) {
+      console.log("");
+      console.log(renderSection("MTP detected", renderRows([
+        ["Feature", "Multi-Token Prediction (speculative decoding)"],
+        ["Mechanism", "oMLX native MTP (enabled via admin API at load time)"],
+      ])));
+      const useMtp = await prompt.yesNo("Use MTP speculative decoding?", true);
+      configured = { ...configured, capabilities: { ...(configured.capabilities ?? {}), mtp: useMtp } };
+    } else if (mtpResult.reason !== "model has no MTP heads in config") {
+      // Model declares MTP but can't use it — surface the reason
+      console.log("");
+      console.log(renderSection("MTP not available", renderRows([
+        ["Feature", "Multi-Token Prediction (speculative decoding)"],
+        ["Reason", pc.yellow(mtpResult.reason)],
+      ])));
+    }
+    // If reason is "no MTP heads in config", don't surface anything —
+    // most models don't have MTP, and showing a card for every non-MTP
+    // model would be noise.
+  }
+
+  console.log("");
+  console.log(renderSection("Model setup", renderRows([
+    ["Model", pc.bold(profile.label)],
+    ["Backend", "oMLX"],
+    ...(configured.capabilities?.mtp ? [["MTP", "enabled"]] : []),
+  ])));
+
+  if (!(await prompt.yesNo("Save profile with these settings?", true))) return null;
+  return configured;
 }
 
 function applyVisionDefaults(profile) {
@@ -248,92 +273,4 @@ function samplingSummary(flags) {
   return `temp ${flags.temperature}, top-p ${flags.topP}, top-k ${flags.topK}`;
 }
 
-// ── MLX profile configuration ─────────────────────────────────────────────
-
-/**
- * Interactive configuration for an mlx-vlm profile.
- */
-export async function configureMlxProfile(prompt, profile) {
-  let configured = profile;
-
-  console.log("");
-  console.log(renderSection("Model setup", renderRows([
-    ["Model", pc.bold(profile.label)],
-    ["Detected", mlxDetectionSummary(configured.capabilities)],
-    ["Context", String(configured.flags.ctxSize) + " tokens"],
-  ])));
-  console.log(pc.dim("Larger context windows use more memory. You can edit the profile later if needed.\n"));
-
-  if (configured.capabilities.vision) {
-    console.log(renderSection("Vision detected", renderRows([
-      ["Capability", "image / multimodal input"],
-      ["Note", "mlx-vlm loads vision from the model directory automatically."],
-    ])));
-  }
 
-  if (configured.capabilities.thinking) {
-    console.log("");
-    console.log(renderSection("Thinking mode", renderRows([
-      ["Flag", "--enable-thinking"],
-      ["Default", "on for Qwen 3 / Gemma 4 / DeepSeek-R class models"],
-    ])));
-    const useThinking = await prompt.yesNo("Enable thinking mode?", true);
-    configured = await applyMlxThinkingToggle(configured, useThinking);
-  }
-
-  const ctxSize = await prompt.number("Context window tokens", configured.flags.ctxSize, 1024, 1048576);
-  configured = applyMlxContextSize(configured, ctxSize);
-
-  console.log("\n" + renderMlxMemoryEstimate(configured));
-
-  console.log("");
-  console.log(renderSection("Defaults", renderRows([
-    ["Backend", configured.backend],
-    ["Endpoint", configured.baseUrl],
-    ["Context", String(configured.flags.ctxSize) + " tokens"],
-    ["Thinking", configured.capabilities?.thinking ? "on" : "off"],
-    ["Vision", configured.capabilities.vision ? "yes" : "no"],
-  ])));
-
-  if (!(await prompt.yesNo("Save profile with these settings?", true))) return null;
-  return configured;
-}
-
-async function applyMlxThinkingToggle(profile, enabled) {
-  if (!profile.capabilities.thinking) return profile;
-  return {
-    ...profile,
-    capabilities: { ...profile.capabilities, thinkingEnabled: enabled },
-  };
-}
-
-function applyMlxContextSize(profile, ctxSize) {
-  const flags = { ...profile.flags, ctxSize };
-  return {
-    ...profile,
-    flags,
-    baseUrl: baseUrlForFlags(flags),
-  };
-}
-
-function renderMlxMemoryEstimate(profile) {
-  const modelBytes = profile.modelSizeBytes || 0;
-  if (!modelBytes) {
-    return renderSection("Memory estimate", pc.dim("Model size unknown — save the profile to estimate."));
-  }
-  const totalMb = estimateMemoryMb(modelBytes);
-  const overheadBytes = Math.max(0, totalMb * 1024 * 1024 - modelBytes);
-  return renderSection("Memory estimate", renderRows([
-    ["Estimated total", pc.bold(`~${formatBytes(totalMb * 1024 * 1024)}`)],
-    ["Model", formatBytes(modelBytes)],
-    ["Overhead", `~${formatBytes(overheadBytes)} (KV cache, APC, runtime)`],
-  ]));
-}
-
-function mlxDetectionSummary(caps) {
-  const parts = [];
-  if (caps.architecture) parts.push(caps.architecture);
-  if (caps.thinking) parts.push("thinking");
-  if (caps.vision) parts.push("vision");
-  return parts.length > 0 ? parts.join(" · ") : "standard MLX";
-}