offgrid-ai 0.15.9 → 0.16.3

package/src/harness-pi.mjs

@@ -8,13 +8,11 @@ import pc from "picocolors";
 // ── Pi model id ─────────────────────────────────────────────────────────────
 
 /**
- * The model id Pi must send in requests. mlx-vlm registers the loaded model
- * with the full --model path as its API id (verified via /v1/models); sending
- * the repo-id label instead makes mlx-vlm unload the local model and re-fetch
- * the repo from HuggingFace. Other backends use the friendly modelAlias.
+ * The model id Pi must send in requests. All backends use the friendly
+ * modelAlias as the API model id.
  */
 export function piApiModelId(profile) {
-  return profile.backend === "mlx-vlm" ? profile.modelPath : profile.modelAlias;
+  return profile.modelAlias;
 }
 
 // ── Sync Pi config ─────────────────────────────────────────────────────────
@@ -87,7 +85,7 @@ async function activeProviderProfiles(currentProfile) {
   const byAlias = new Map();
   for (const item of [...allProfiles, currentProfile]) {
     if (item.providerId !== currentProfile.providerId) continue;
-    if (item.backend !== "llama-cpp" && item.backend !== "llama-cpp-mtp") {
+    if (item.backend !== "llama-cpp") {
       byAlias.set(item.modelAlias, item);
       continue;
     }
@@ -135,7 +133,7 @@ export function modelReasoning(profile) {
 }
 
 export function modelFamily(profile) {
-  return [profile.id, profile.label, profile.modelAlias, profile.modelPath, profile.omlxModel].filter(Boolean).join(" ").toLowerCase();
+  return [profile.id, profile.label, profile.modelAlias, profile.omlxModel].filter(Boolean).join(" ").toLowerCase();
 }
 
 function piApiKey() {

package/src/managed.mjs

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs";
 import { BACKENDS } from "./backends.mjs";
-import { commandExists } from "./exec.mjs";
+import { hasOmlx } from "./omlx-runtime.mjs";
 
 export const MANAGED_BACKEND_IDS = ["omlx"];
 
@@ -22,6 +22,6 @@ export function hasLmStudioInstalled() {
   return existsSync("/Applications/LM Studio.app");
 }
 
-export function hasOmlxInstalled() {
-  return commandExists("omlx");
+export async function hasOmlxInstalled() {
+  return await hasOmlx();
 }

package/src/mlx-discovery.mjs

@@ -1,36 +1,14 @@
-// MLX model discovery + metadata — scans configured model directories for MLX
-// model directories and parses their config.json.
-// Ported from deprecated-offgrid-desktop/src/main/model-discovery.ts +
-// mlx-metadata.ts (MLX subset only).
-//
-// This runs ALONGSIDE offgrid-ai's existing GGUF scan (scan.mjs scanGgufModels)
-// — it does not replace it. The picker (main.mjs) will merge GGUF + MLX lists.
-//
-// An MLX model directory is one containing config.json + one or more
-// *.safetensors files. HuggingFace Hub cache layout (models--org--name) is
-// detected and scanned specially.
+// oMLX model size lookup — scans ~/.omlx/models/ for MLX model directories
+// to compute sizes and publishers. The oMLX API doesn't return these, so we
+// read them from disk.
 
 import { readdir, stat, readFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
-import { join, basename } from "node:path";
+import { join } from "node:path";
 import { homedir } from "node:os";
-import { getModelScanDirs } from "./config.mjs";
-import { inferSourceLabel, MIN_MODEL_SIZE_BYTES, EMBEDDING_MODEL_TYPES } from "./discovery-shared.mjs";
-import { parseModelName } from "./model-name.mjs";
 
-// ── Folder → backend mapping ──────────────────────────────────────────────
-// The oMLX folder is oMLX-exclusive: models there are served by the oMLX
-// managed backend, NOT by mlx-vlm. Every OTHER scan dir is format-based
-// (GGUF → llama.cpp, MLX → mlx-vlm). So mlx-vlm scans all configured dirs
-// EXCEPT the oMLX folder.
 const OMLX_MODELS_DIR = join(homedir(), ".omlx", "models");
-function isOmlxFolder(p) {
-  return p === OMLX_MODELS_DIR || p.startsWith(OMLX_MODELS_DIR + "/");
-}
-
-// ── MLX directory detection ───────────────────────────────────────────────
 
-/** True if dir contains config.json + at least one .safetensors file. */
 async function isMlxModelDir(dir) {
   if (!existsSync(join(dir, "config.json"))) return false;
   try {
@@ -41,7 +19,6 @@ async function isMlxModelDir(dir) {
   }
 }
 
-/** Sum the size of all .safetensors files in an MLX model dir (bytes). */
 async function getMlxDirSizeBytes(dir) {
   try {
     const entries = await readdir(dir);
@@ -57,290 +34,132 @@ async function getMlxDirSizeBytes(dir) {
   }
 }
 
-// ── Recursive MLX scanner ─────────────────────────────────────────────────
-
 /**
- * Recursively scan a directory for MLX model directories.
- * Searches up to maxDepth levels deep. Does NOT collect GGUF (that's scan.mjs).
+ * Scan ~/.omlx/models/ for MLX model directories and return a Map of
+ * basename → { sizeBytes, publisher }.
  */
-async function scanDirRecursiveForMlx(rootDir, sourceLabel, maxDepth = 3) {
-  if (!existsSync(rootDir)) return [];
-  const models = [];
+export async function scanOmlxModelSizes() {
+  if (!existsSync(OMLX_MODELS_DIR)) return new Map();
+  const infoByBasename = new Map();
 
-  async function walk(dir, depth) {
-    if (depth > maxDepth) return;
+  async function walk(dir, publisher) {
     let entries;
     try {
       entries = await readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
-
-    // Is this directory itself an MLX model dir? (don't recurse into it)
-    if (depth > 0 && await isMlxModelDir(dir)) {
-      const sizeBytes = await getMlxDirSizeBytes(dir);
-      if (sizeBytes < MIN_MODEL_SIZE_BYTES) return;
-      if (await isEmbeddingMlxModel(join(dir, "config.json"))) return;
-      const caps = await detectMlxCapabilities(dir);
-      const { display, quant } = parseModelName(basename(dir), sourceLabel);
-      models.push(makeMlxModel(dir, display, sizeBytes, sourceLabel, rootDir, caps.contextLength, quant));
-      return;
-    }
-
     for (const entry of entries) {
-      if (entry.name.startsWith(".") || entry.name === "README.md" || entry.name === ".gitattributes") continue;
+      if (!entry.isDirectory()) continue;
       const fullPath = join(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (await isMlxModelDir(fullPath)) {
-          const sizeBytes = await getMlxDirSizeBytes(fullPath);
-          if (sizeBytes < MIN_MODEL_SIZE_BYTES) continue;
-          if (await isEmbeddingMlxModel(join(fullPath, "config.json"))) continue;
-          const caps = await detectMlxCapabilities(fullPath);
-          // Extract publisher from parent dir (LM Studio: publisher/model-dir)
-          const relParts = fullPath.slice(rootDir.length + 1).split("/");
-          const publisher = (sourceLabel === "lmstudio" && relParts.length >= 2) ? relParts[0] : null;
-          const rawLabel = publisher ? `${publisher}/${entry.name}` : entry.name;
-          const { display, quant } = parseModelName(rawLabel, sourceLabel);
-          models.push(makeMlxModel(fullPath, display, sizeBytes, sourceLabel, rootDir, caps.contextLength, quant));
-        } else {
-          await walk(fullPath, depth + 1);
-        }
+      if (await isMlxModelDir(fullPath)) {
+        const sizeBytes = await getMlxDirSizeBytes(fullPath);
+        if (sizeBytes > 0) infoByBasename.set(entry.name, { sizeBytes, publisher });
+      } else {
+        await walk(fullPath, publisher ?? entry.name);
       }
     }
   }
 
-  await walk(rootDir, 0);
-  return models;
+  await walk(OMLX_MODELS_DIR, null);
+  return infoByBasename;
 }
 
-// ── HuggingFace Hub layout ────────────────────────────────────────────────
+// ── MTP capability detection ─────────────────────────────────────────────
+// oMLX supports native MTP for Qwen 3.5/3.6 (dense + MoE) and DeepSeek-V4
+// models that ship MTP heads in their weights. The check mirrors oMLX's own
+// _mtp_compat_for_model: config must declare mtp_num_hidden_layers, model_type
+// must be on the whitelist, and the safetensors index must contain mtp.* keys.
 
-/** True if dir looks like an HF Hub cache (has models--* subdirs). */
-async function looksLikeHfHub(dir) {
-  if (!existsSync(dir)) return false;
-  try {
-    const entries = await readdir(dir, { withFileTypes: true });
-    return entries.some((e) => e.isDirectory() && e.name.startsWith("models--"));
-  } catch {
-    return false;
-  }
-}
+const MTP_MODEL_TYPES = ["qwen3_5", "qwen3_5_moe", "qwen3_6", "qwen3_6_moe", "deepseek_v4"];
 
 /**
- * Scan an HF Hub cache dir for MLX model dirs.
- * HF layout: models--org--name/snapshots/hash/files
+ * Check if an oMLX model directory supports native MTP.
+ * Returns { compatible: boolean, reason: string }.
  */
-async function scanHfHubForMlx(dir, sourceLabel) {
-  if (!existsSync(dir)) return [];
-  const models = [];
-  try {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory() || !entry.name.startsWith("models--")) continue;
-      const parts = entry.name.slice("models--".length).split("--");
-      const label = parts.join("/");
-      const snapshotsDir = join(dir, entry.name, "snapshots");
-      if (!existsSync(snapshotsDir)) continue;
-      const snapshots = await readdir(snapshotsDir, { withFileTypes: true });
-      // Follow symlinks (HF hub uses them; test imports use them too). A model
-      // dir can have several snapshots — some incomplete/empty. Check EACH
-      // snapshot and use the first that is a valid MLX model dir, rather than
-      // giving up on the whole model if the first snapshot happens to be empty.
-      const candidates = snapshots.filter((s) => s.isDirectory() || s.isSymbolicLink());
-      let snapshotPath = null;
-      for (const snap of candidates) {
-        const sp = join(snapshotsDir, snap.name);
-        const st = await stat(sp).catch(() => null);
-        if (st?.isDirectory() && await isMlxModelDir(sp)) { snapshotPath = sp; break; }
-      }
-
-      if (!snapshotPath) continue;
-      const sizeBytes = await getMlxDirSizeBytes(snapshotPath);
-      if (sizeBytes < MIN_MODEL_SIZE_BYTES) continue;
-      if (await isEmbeddingMlxModel(join(snapshotPath, "config.json"))) continue;
-      const caps = await detectMlxCapabilities(snapshotPath);
-      const { display, quant } = parseModelName(label, sourceLabel);
-      models.push({
-        id: `${sourceLabel}:${entry.name}`,
-        label: display,
-        path: snapshotPath,
-        filePath: snapshotPath,
-        sizeBytes,
-        contextLength: caps.contextLength,
-        quant,
-        backend: "mlx-vlm",
-        format: "mlx",
-        source: sourceLabel,
-      });
-    }
-  } catch {
-    // Can't read — return what we have.
-  }
-  return models;
-}
-
-// ── Embedding model filtering for MLX ─────────────────────────────────────
+export async function detectOmlxMtpCapability(modelDir) {
+  const configPath = join(modelDir, "config.json");
+  if (!existsSync(configPath)) return { compatible: false, reason: "config.json not found" };
 
-async function isEmbeddingMlxModel(configPath) {
-  if (!existsSync(configPath)) return false;
+  let config;
   try {
-    const config = JSON.parse(await readFile(configPath, "utf-8"));
-    const textConfig = config.text_config ?? config;
-    const modelType = String(textConfig.model_type ?? "").toLowerCase();
-    if (EMBEDDING_MODEL_TYPES.has(modelType)) return true;
-    const arch = Array.isArray(config.architectures) ? config.architectures[0] : "";
-    const lowerArch = String(arch).toLowerCase();
-    return EMBEDDING_MODEL_TYPES.has(lowerArch) || lowerArch.includes("bert");
+    config = JSON.parse(await readFile(configPath, "utf8"));
   } catch {
-    return false;
+    return { compatible: false, reason: "failed to read config.json" };
   }
-}
 
-// ── MLX model entry builder ───────────────────────────────────────────────
+  const mtpLayers = config.mtp_num_hidden_layers;
+  if (!mtpLayers || mtpLayers <= 0) {
+    return { compatible: false, reason: "model has no MTP heads in config" };
+  }
 
-function makeMlxModel(dir, label, sizeBytes, sourceLabel, rootDir, contextLength = null, quant = null) {
-  return {
-    id: `${sourceLabel}:${dir.replace(rootDir + "/", "")}`,
-    label,
-    path: dir,
-    filePath: dir,
-    sizeBytes,
-    contextLength,
-    quant,
-    backend: "mlx-vlm",
-    format: "mlx",
-    source: sourceLabel,
-  };
-}
+  const modelType = config.model_type;
+  if (!MTP_MODEL_TYPES.some((t) => modelType === t || modelType?.startsWith(t))) {
+    return { compatible: false, reason: `model_type=${modelType} is not on the MTP whitelist (supported: ${MTP_MODEL_TYPES.join(", ")})` };
+  }
 
-// ── Public API ─────────────────────────────────────────────────────────────
+  // Check for mtp.* weight tensors in the safetensors index
+  const hasWeights = await modelHasMtpWeights(modelDir);
+  if (!hasWeights) {
+    return { compatible: false, reason: "Config declares MTP layers but the converted weights are missing mtp.* tensors. Re-convert from HF with a converter that preserves MTP weights." };
+  }
 
-/**
- * Discover all MLX models across the configured scan directories.
- * Reads scan dirs from config.mjs getModelScanDirs() — same paths GGUF uses
- * (LM Studio, HF hub, user-added). Returns a flat, deduplicated list.
- */
-export async function scanMlxModels(dirs) {
-  // mlx-vlm scans every configured dir EXCEPT the oMLX folder (oMLX-exclusive).
-  const scanDirs = (dirs ?? await getModelScanDirs()).filter((d) => !isOmlxFolder(d));
-  const results = await Promise.all(
-    scanDirs.map(async (dir) => {
-      const label = inferSourceLabel(dir);
-      if (await looksLikeHfHub(dir)) return scanHfHubForMlx(dir, label);
-      return scanDirRecursiveForMlx(dir, label);
-    }),
-  );
-  const all = results.flat();
-  // Deduplicate by filePath (same model may appear in multiple paths).
-  const seen = new Set();
-  return all.filter((m) => {
-    if (seen.has(m.filePath)) return false;
-    seen.add(m.filePath);
-    return true;
-  });
+  return { compatible: true, reason: "" };
 }
 
-// ── MLX capability detection ─────────────────────────────────────────────
-
-/**
- * Detect MLX model capabilities from its config.json.
- * Returns { architecture, thinking, vision, contextLength }.
- */
-export async function detectMlxCapabilities(modelDir) {
-  const configPath = join(modelDir, "config.json");
-  if (!existsSync(configPath)) return { thinking: false, vision: false, contextLength: null, architecture: null };
+async function modelHasMtpWeights(modelDir) {
+  const indexPath = join(modelDir, "model.safetensors.index.json");
+  if (existsSync(indexPath)) {
+    try {
+      const index = JSON.parse(await readFile(indexPath, "utf8"));
+      const weightMap = index.weight_map ?? {};
+      return Object.keys(weightMap).some((key) => key.includes("mtp."));
+    } catch {
+      return false;
+    }
+  }
+  // Single-shard fallback: can't easily read safetensors keys in Node without
+  // the safetensors library. Check for an mtp-specific safetensors file.
   try {
-    const config = JSON.parse(await readFile(configPath, "utf-8"));
-    return detectMlxCapabilitiesFromConfig(config, modelDir);
+    const entries = await readdir(modelDir);
+    return entries.some((f) => f.endsWith(".safetensors") && /mtp/i.test(f));
   } catch {
-    return { thinking: false, vision: false, contextLength: null, architecture: null };
+    return false;
   }
 }
 
-export function detectMlxCapabilitiesFromConfig(config, modelDir) {
-  const textConfig = config.text_config ?? config;
-  const rawName = config._name_or_path ?? basename(modelDir ?? "");
-  const name = String(rawName).toLowerCase();
-  const label = String(rawName);
-
-  const modelType = String(config.model_type ?? "").toLowerCase();
-  const textModelType = String(textConfig.model_type ?? "").toLowerCase();
-
-  const vision = Boolean(
-    config.vision_config ||
-    config.image_token_id != null ||
-    config.video_token_id != null ||
-    config.vision_start_token_id != null ||
-    modelType.includes("vl") ||
-    modelType.includes("vision") ||
-    textModelType.includes("vl") ||
-    textModelType.includes("vision")
-  );
-
-  const thinking = /qwen3|gemma-4|gemma4|deepseek-r[12]/i.test(name + " " + label);
-
-  const architectures = Array.isArray(config.architectures) ? config.architectures : [];
-  const architecture = architectures[0] ?? null;
-
-  const candidates = [
-    textConfig.max_position_embeddings,
-    textConfig.sliding_window,
-    config.max_position_embeddings,
-    config.sliding_window,
-  ].filter((v) => typeof v === "number" && v > 0);
-  const contextLength = candidates.length > 0 ? Math.max(...candidates) : null;
-
-  return { thinking, vision, contextLength, architecture };
-}
-
-/**
- * Pick a sensible default context length for an MLX model, capping by RAM.
- */
-export function defaultMlxContextLength(trainedCtx, ramGb) {
-  if (!trainedCtx || trainedCtx <= 0) return 8192;
-  if (ramGb < 12) return Math.min(trainedCtx, 4096);
-  if (ramGb < 16) return Math.min(trainedCtx, 8192);
-  if (ramGb < 32) return Math.min(trainedCtx, 16384);
-  return trainedCtx;
-}
-
-// ── oMLX model size lookup (from disk) ────────────────────────────────────
-
 /**
- * Scan the oMLX models directory (~/.omlx/models/) for MLX model directories
- * and return a Map of basename → { sizeBytes, publisher }.  The oMLX API
- * doesn't return model sizes or publishers, so we compute them from disk.
+ * Find the model directory for a given oMLX model ID.
+ * Searches ~/.omlx/models/ recursively for a directory matching the model ID.
  */
-export async function scanOmlxModelSizes() {
-  if (!existsSync(OMLX_MODELS_DIR)) return new Map();
-  const infoByBasename = new Map();
+export async function findOmlxModelDir(modelId) {
+  if (!existsSync(OMLX_MODELS_DIR)) return null;
+  const basename = modelId.includes("/") ? modelId.slice(modelId.lastIndexOf("/") + 1)
+    : modelId.includes("--") ? modelId.slice(modelId.lastIndexOf("--") + 2)
+    : modelId;
 
-  async function walk(dir, publisher) {
+  async function walk(dir) {
     let entries;
     try {
       entries = await readdir(dir, { withFileTypes: true });
     } catch {
-      return;
+      return null;
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const fullPath = join(dir, entry.name);
-      if (await isMlxModelDir(fullPath)) {
-        const sizeBytes = await getMlxDirSizeBytes(fullPath);
-        if (sizeBytes > 0) infoByBasename.set(entry.name, { sizeBytes, publisher });
-      } else {
-        // First-level directories under ~/.omlx/models/ are publishers
-        await walk(fullPath, publisher ?? entry.name);
-      }
+      if (entry.name === basename && await isMlxModelDir(fullPath)) return fullPath;
+      const found = await walk(fullPath);
+      if (found) return found;
     }
+    return null;
   }
 
-  await walk(OMLX_MODELS_DIR, null);
-  return infoByBasename;
+  return await walk(OMLX_MODELS_DIR);
 }
 
 /**
- * Look up a model's info by its oMLX API id.  Tries exact match, then the
+ * Look up a model's info by its oMLX API id. Tries exact match, then the
  * segment after `--` (oMLX org--name format), then after `/` (HF format).
  */
 export function lookupOmlxModelInfo(modelId, infoMap) {

package/src/model-catalog.mjs

@@ -1,28 +1,23 @@
 import { scanGgufModels, matchDrafter } from "./scan.mjs";
 import { loadProfiles, normalizeProfile, sanitizeProfileId } from "./profiles.mjs";
 import { scanManagedModels } from "./managed.mjs";
-import { scanMlxModels } from "./mlx-discovery.mjs";
 import { isProfileFileMissing } from "./model-summary.mjs";
 import { backendFor } from "./backends.mjs";
 
 export async function loadModelCatalog() {
-  const [profiles, { models: ggufModels, drafters }, managedModels, mlxModels] = await Promise.all([
+  const [profiles, { models: ggufModels, drafters }, managedModels] = await Promise.all([
     loadProfiles(),
     scanGgufModels(),
     scanManagedModels(),
-    scanMlxModels(),
   ]);
-  return normalizeCatalog({ profiles, ggufModels, drafters, managedModels, mlxModels });
+  return normalizeCatalog({ profiles, ggufModels, drafters, managedModels });
 }
 
 export function normalizeCatalog(catalog) {
   if (catalog.newModels && catalog.managedItems) return catalog;
-  const { profiles, ggufModels, drafters, managedModels, mlxModels = [] } = catalog;
+  const { profiles, ggufModels, drafters, managedModels } = catalog;
   const profiledPaths = new Set(profiles.map((profile) => profile.modelPath).filter(Boolean));
-  const newModels = [
-    ...ggufModels.filter((model) => !profiledPaths.has(model.path)),
-    ...mlxModels.filter((model) => !profiledPaths.has(model.path)),
-  ];
+  const newModels = ggufModels.filter((model) => !profiledPaths.has(model.path));
   const managedItems = [];
   for (const { backendId, models, status } of managedModels) {
     if (status === "unavailable") continue;
@@ -35,9 +30,10 @@ export function normalizeCatalog(catalog) {
       if (!profiledAliases.has(`${backendId}:${model.id}`)) managedItems.push({ model, backendId });
     }
   }
-  return { profiles, ggufModels, drafters, managedModels, mlxModels, newModels, managedItems };
+  return { profiles, ggufModels, drafters, managedModels, newModels, managedItems };
 }
 
+
 export function itemKey(item) {
   if (item.type === "profile") return `profile:${item.profile.id}`;
   if (item.type === "new") return `new:${item.model.path}`;
@@ -57,12 +53,11 @@ function compareRecency(a, b) {
 }
 
 export function buildCatalogItems(normalized) {
-  const { profiles, newModels, managedItems, drafters, ggufModels = [], mlxModels = [], managedModels = [] } = normalized;
+  const { profiles, newModels, managedItems, drafters, ggufModels = [], managedModels = [] } = normalized;
 
   // Lookup maps for enriching profile items with scan data (size + context).
   const scanByPath = new Map();
   for (const m of ggufModels) scanByPath.set(m.path, m);
-  for (const m of mlxModels) scanByPath.set(m.filePath ?? m.path, m);
 
   const managedByKey = new Map();
   for (const { backendId, models } of managedModels) {
@@ -77,7 +72,7 @@ export function buildCatalogItems(normalized) {
     if (profile.modelPath) {
       const scanModel = scanByPath.get(profile.modelPath);
       if (scanModel) {
-        item.label = scanModel.label;  // re-parsed label (publisher/model-name)
+        item.label = scanModel.label;
         if (scanModel.quant) quant = scanModel.quant;
       }
     }
@@ -160,4 +155,4 @@ export function createManagedProfile(model, backendId) {
     modelSizeBytes: model.sizeBytes || 0,
     ...(backendId === "omlx" ? { omlxModel: model.id } : {}),
   });
-}
+}

package/src/model-presenters.mjs

@@ -44,8 +44,6 @@ function optionSourceTag(sourceId) {
     omlx: pc.magenta,
     "llama.cpp": pc.cyan,
     gguf: pc.cyan,
-    mlx: pc.yellow,
-    "mlx-vlm": pc.yellow,
   };
   return optionPad(label, colors[sourceId] ?? pc.dim, OPTION_SOURCE_WIDTH);
 }
@@ -55,9 +53,7 @@ function optionBackendTag(backendId) {
   const label = backend?.label ?? backendId ?? "unknown";
   const colors = {
     "llama-cpp": pc.cyan,
-    "llama-cpp-mtp": pc.blue,
     omlx: pc.magenta,
-    "mlx-vlm": pc.yellow,
   };
   return optionPad(label, colors[backendId] ?? pc.dim, OPTION_BACKEND_WIDTH);
 }
@@ -70,8 +66,6 @@ export function formatSourceLabel(sourceId) {
     omlx: "oMLX",
     "llama.cpp": "llama.cpp",
     gguf: "GGUF file",
-    mlx: "MLX",
-    "mlx-vlm": "MLX",
   };
   return map[sourceId] ?? String(sourceId);
 }
@@ -200,7 +194,6 @@ export function inferBackendId(item) {
   if (item.type === "profile") return item.profile.backend;
   if (item.type === "managed") return item.backendId;
   // new model: derive from format
-  if (item.model?.format === "mlx") return "mlx-vlm";
   if (item.model?.backend) return item.model.backend;
   return "llama-cpp";
 }
@@ -297,29 +290,6 @@ export function printGgufModelDetails(model, drafter) {
   console.log("\n" + renderSectionRows("Model details", detailRows, { columns: Math.min(process.stdout.columns ?? 110, 140) }));
 }
 
-export async function printMlxModelDetails(model) {
-  const { detectMlxCapabilities } = await import("./mlx-discovery.mjs");
-  const caps = await detectMlxCapabilities(model.filePath ?? model.path);
-  const parts = [];
-  if (caps.architecture) parts.push(caps.architecture);
-  if (caps.thinking) parts.push("thinking");
-  if (caps.vision) parts.push("vision");
-  const summary = parts.length > 0 ? parts.join(pc.dim(" · ")) : "standard MLX";
-  console.log("\n" + renderSectionRows("Downloaded model", [
-    ["Name", pc.bold(model.label)],
-    ["Status", pc.yellow("Needs one-time setup")],
-    ["Details", summary],
-  ]));
-  console.log("\n" + renderSectionRows("Model details", [
-    ["Model dir", model.path],
-    ["Backend", "mlx-vlm"],
-    ["Source", formatSourceLabel(model.source)],
-    ["Detected", summary],
-    ["Size", formatBytes(model.sizeBytes)],
-    ["Context", caps.contextLength ? `${caps.contextLength.toLocaleString()} trained` : "unknown"],
-  ], { columns: Math.min(process.stdout.columns ?? 110, 140) }));
-}
-
 export function printManagedModelDetails(model, backend) {
   console.log("\n" + renderSectionRows(`${backend.label} model`, [
     ["Name", pc.bold(model.label)],