offgrid-ai 0.16.0 → 0.17.0

package/src/profile-setup.mjs

@@ -3,22 +3,39 @@ 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 { capabilitySummary } from "./model-summary.mjs";
+import { detectOmlxMtpCapability, findOmlxModelDir } from "./mlx-discovery.mjs";
 
 const execFileAsync = promisify(execFile);
 
 const CACHE_CHOICES = [
-  { value: "bf16", label: "bf16", hint: "default: stable, good quality" },
-  { value: "f16", label: "f16", hint: "stable fallback, similar memory to bf16" },
-  { value: "q8_0", label: "q8_0", hint: "lower memory, usually safe" },
-  { value: "q4_0", label: "q4_0", hint: "lowest memory, quality/speed tradeoff" },
+  { value: "bf16", label: "bf16", hint: "16-bit · best quality · 2 bytes/elem" },
+  { value: "f16", label: "f16", hint: "16-bit · stable fallback · 2 bytes/elem" },
+  { value: "q8_0", label: "q8_0", hint: "8-bit · half memory · usually safe · 1 byte/elem" },
+  { value: "q4_0", label: "q4_0", hint: "4-bit · quarter memory · quality tradeoff · 0.5 bytes/elem" },
 ];
 
+function quickKvBytes(modelPath, flags) {
+  try {
+    return estimateMemory(modelPath, null, null, flags).kvBytes;
+  } catch {
+    return 0;
+  }
+}
+
+function cacheMemoryRows(modelPath, flags, ctxSize) {
+  const combos = [["bf16", "bf16"], ["f16", "f16"], ["q8_0", "q8_0"], ["q4_0", "q4_0"]];
+  return combos.map(([k, v]) => {
+    const bytes = quickKvBytes(modelPath, { ...flags, ctxSize, cacheTypeK: k, cacheTypeV: v });
+    return [`${k}/${v} KV cache`, bytes ? `~${formatBytes(bytes)}` : "unknown"];
+  });
+}
+
 const GENERAL_DEFAULTS = {
   topK: 20,
   presencePenalty: 1.5,
@@ -39,7 +56,6 @@ export async function configureLocalProfile(prompt, profile) {
   const freshCaps = detectCapabilities(profile.modelPath, profile.mmprojPath);
   let drafterPath = profile.drafterPath ?? null;
   if (drafterPath && !existsSync(drafterPath)) {
-    // Stored drafter is no longer on disk — drop it and re-scan for a fresh one.
     drafterPath = null;
   }
   if (!drafterPath) {
@@ -49,97 +65,229 @@ 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 };
-  }
-  // If vision was previously disabled but mmproj is back, re-enable
+  configured = { ...configured, drafterPath: drafterPath ?? null, capabilities: { ...configured.capabilities, mtp: hasMtp } };
   if (configured.disabledMmprojPath && configured.mmprojPath === null && freshCaps.vision) {
     configured = { ...configured, mmprojPath: configured.disabledMmprojPath, disabledMmprojPath: undefined, capabilities: { ...configured.capabilities, vision: true, visionDisabledReason: undefined } };
   }
 
+  // ── Model overview ──────────────────────────────────────────────────────
   console.log("");
-  console.log(renderSection("Model setup", renderRows([
+  console.log(renderSection("Model overview", renderRows([
     ["Model", pc.bold(profile.label)],
     ["Detected", capabilitySummary(caps)],
-    ["Context", `${profile.flags.ctxSize.toLocaleString()} tokens`],
-    ["KV cache", `${profile.flags.cacheTypeK}/${profile.flags.cacheTypeV}`],
-    ["Sampling", samplingSummary(profile.flags)],
+    ["Backend", "llama.cpp (local server)"],
+    ["Model file", profile.modelPath],
   ])));
-  console.log(pc.dim("Larger context windows use more memory. KV cache precision controls memory used by attention history."));
-  console.log(pc.dim("Sampling defaults are shown for transparency; you can edit the profile later if needed.\n"));
 
+  // ── MTP ────────────────────────────────────────────────────────────────
   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)],
-      ["Flags", `--spec-type draft-mtp --spec-draft-n-max 4${configured.drafterPath ? " --spec-draft-model <drafter>" : ""}`],
-    ])));
-    if (drafterInfo) console.log(pc.dim(drafterInfo));
-    const useMtp = await prompt.yesNo("Use MTP speculative decoding?", true);
-    configured = useMtp ? applyMtpDefaults(configured) : removeMtpDefaults(configured);
-  }
-
-  if (caps.qat) {
     console.log("");
-    console.log(renderSection("QAT detected", renderRows([
-      ["Meaning", "quantization-aware trained"],
-      ["Runtime flags", "none QAT-specific"],
+    console.log(renderSection("MTP (Multi-Token Prediction)", renderRows([
+      ["What it does", "Speculative decoding — predicts multiple tokens at once, verifies them"],
+      ["Speed", "1.5–3x faster generation"],
+      ["Quality", "No loss — rejected predictions fall back to normal"],
+      ["Memory", "Slightly more for draft model weights"],
+      ["Flags", "--spec-type draft-mtp --spec-draft-n-max 4"],
+      ...(configured.drafterPath ? [["Drafter", configured.drafterPath]] : []),
     ])));
+    const useMtp = await prompt.yesNo("Enable MTP speculative decoding?", true);
+    configured = useMtp ? applyMtpDefaults(configured) : removeMtpDefaults(configured);
   }
 
+  // ── Vision ─────────────────────────────────────────────────────────────
   if (caps.vision && profile.mmprojPath) {
     console.log("");
     const gemma4Unified = isGemma4UnifiedProjector(caps.mmprojProjectorType);
     const supported = !gemma4Unified || await runtimeSupportsGemma4Unified();
-    console.log(renderSection("Vision projector detected", renderRows([
-      ["Projector", caps.mmprojProjectorType ?? "unknown"],
+    console.log(renderSection("Vision projector", renderRows([
+      ["What it does", "Enables image understanding — model can see and reason about images"],
+      ["Projector type", caps.mmprojProjectorType ?? "unknown"],
       ["Flag", `--mmproj ${profile.mmprojPath}`],
+      ["Memory", "~200 MB for projector weights (varies by model)"],
       ...(gemma4Unified && !supported ? [["Note", pc.yellow("Gemma 4 unified projectors need llama.cpp b9549+.")]] : []),
     ])));
-    const useVision = await prompt.yesNo("Enable vision with --mmproj?", supported);
+    const useVision = await prompt.yesNo("Enable vision?", supported);
     configured = useVision ? applyVisionDefaults(configured) : removeVisionDefaults(configured, gemma4Unified && !supported ? "gemma4-unified-unsupported" : "user-disabled");
   }
 
+  // ── Thinking ───────────────────────────────────────────────────────────
   if (caps.thinking) {
     console.log("");
-    console.log(renderSection("Thinking model detected", renderRows([
-      ["Defaults", "thinking / loop-safe"],
-      ["Flags", "--top-k 64 --presence-penalty 0 --repeat-penalty 1.1"],
+    console.log(renderSection("Thinking mode", renderRows([
+      ["What it does", "Model reasons step-by-step before answering"],
+      ["Benefit", "Better results for math, code, logic — but slower (more output tokens)"],
+      ["Sampling changes", "top-k → 64, presence penalty → 0, repeat penalty → 1.1 (adjustable below)"],
       ["Template", "--chat-template-kwargs { enable_thinking: true }"],
     ])));
-    const useThinking = await prompt.yesNo("Use these thinking/loop-safe defaults?", true);
+    const useThinking = await prompt.yesNo("Use thinking/loop-safe defaults?", true);
     configured = useThinking ? applyThinkingDefaults(configured) : removeThinkingDefaults(configured);
   }
 
-  const ctxSize = await prompt.number("Context window tokens", configured.flags.ctxSize, 1024, 1048576);
+  // ── Context window ─────────────────────────────────────────────────────
+  const maxCtx = caps.metaCtx ?? 1048576;
+  console.log("");
+  console.log(renderSection("Context window", renderRows([
+    ["What it does", "Maximum tokens the model can process at once (prompt + response + history)"],
+    ["Range", `1,024 – ${maxCtx.toLocaleString()} tokens`],
+    ["Memory", "KV cache grows linearly — larger context = more RAM"],
+    ["Guidance", "8k–32k: chat · 32k–80k: coding/long convos · 128k+: long documents"],
+    ["Model max", `${maxCtx.toLocaleString()} tokens`],
+    ["Default", `${configured.flags.ctxSize.toLocaleString()} tokens`],
+  ])));
+  const ctxSize = await prompt.number("Context window tokens", configured.flags.ctxSize, 1024, maxCtx);
+  configured = applyRuntimeFlagOverrides(configured, { ctxSize });
+
+  // ── K cache precision ──────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("K cache precision", renderRows([
+    ["What it is", "KV cache stores attention 'keys' — previous token states used for prediction"],
+    ["Tradeoff", "Lower precision = less memory, potential quality loss"],
+    ...cacheMemoryRows(profile.modelPath, configured.flags, ctxSize),
+  ])));
   const cacheTypeK = await prompt.choice("K cache precision", CACHE_CHOICES, configured.flags.cacheTypeK);
+  configured = applyRuntimeFlagOverrides(configured, { cacheTypeK });
+
+  // ── V cache precision ──────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("V cache precision", renderRows([
+    ["What it is", "KV cache stores attention 'values' — token representations from previous layers"],
+    ["Tradeoff", "Same as K cache. Some models are more sensitive to V precision than K"],
+    ...cacheMemoryRows(profile.modelPath, configured.flags, ctxSize),
+  ])));
   const cacheTypeV = await prompt.choice("V cache precision", CACHE_CHOICES, configured.flags.cacheTypeV);
-  configured = applyRuntimeFlagOverrides(configured, { ctxSize, cacheTypeK, cacheTypeV });
+  configured = applyRuntimeFlagOverrides(configured, { cacheTypeV });
+
+  // ── Memory estimate (with chosen context + cache) ──────────────────────
+  console.log("");
+  console.log(renderMemoryEstimate(configured));
+
+  // ── Temperature ────────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Temperature", renderRows([
+    ["What it does", "Controls randomness in token selection"],
+    ["Range", "0.0 – 2.0"],
+    ["0.0", "Deterministic — always picks most likely token"],
+    ["0.6", "Balanced — default for most models"],
+    ["1.0+", "Creative — more random, may hallucinate"],
+    ["Guidance", "0–0.3: coding/factual · 0.4–0.8: chat · 0.9+: creative writing"],
+  ])));
+  const temperature = await prompt.number("Temperature", configured.flags.temperature, 0, 2, { float: true });
+  configured = applyRuntimeFlagOverrides(configured, { temperature });
+
+  // ── Top-p ──────────────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Top-p (nucleus sampling)", renderRows([
+    ["What it does", "Only considers tokens in the top p fraction of probability mass"],
+    ["Range", "0.0 – 1.0 (1.0 = consider all tokens)"],
+    ["Guidance", "0.9–0.95: good default · Lower = more focused · Higher = more diverse"],
+  ])));
+  const topP = await prompt.number("Top-p", configured.flags.topP, 0, 1, { float: true });
+  configured = applyRuntimeFlagOverrides(configured, { topP });
+
+  // ── Top-k ──────────────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Top-k", renderRows([
+    ["What it does", "Limits token selection to top K most likely tokens at each step"],
+    ["Range", "0 – 1000 (0 = disabled, uses top-p instead)"],
+    ["Guidance", "20: general chat · 40–64: thinking/reasoning · 0: rely on top-p"],
+  ])));
+  const topK = await prompt.number("Top-k", configured.flags.topK, 0, 1000);
+  configured = applyRuntimeFlagOverrides(configured, { topK });
+
+  // ── Min-p ──────────────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Min-p", renderRows([
+    ["What it does", "Excludes tokens with probability below this threshold"],
+    ["Range", "0.0 – 1.0 (0 = disabled)"],
+    ["Guidance", "0: off (default) · 0.05–0.1: reduces hallucination while keeping creativity"],
+  ])));
+  const minP = await prompt.number("Min-p", configured.flags.minP, 0, 1, { float: true });
+  configured = applyRuntimeFlagOverrides(configured, { minP });
+
+  // ── Presence penalty ───────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Presence penalty", renderRows([
+    ["What it does", "Discourages repeated tokens — each used token gets a fixed logit penalty"],
+    ["Range", "0.0 – 2.0 (0 = off)"],
+    ["Guidance", "0: thinking/reasoning · 1.0–1.5: general chat · Too high = incoherent"],
+  ])));
+  const presencePenalty = await prompt.number("Presence penalty", configured.flags.presencePenalty, 0, 2, { float: true });
+  configured = applyRuntimeFlagOverrides(configured, { presencePenalty });
+
+  // ── Repeat penalty ─────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Repeat penalty", renderRows([
+    ["What it does", "Multiplies probability of repeated tokens (multiplicative, vs presence's additive)"],
+    ["Range", "0.0 – 2.0 (1.0 = no effect)"],
+    ["Guidance", "1.0–1.1: most use cases · Higher = aggressive anti-repeat · Can break code patterns"],
+  ])));
+  const repeatPenalty = await prompt.number("Repeat penalty", configured.flags.repeatPenalty, 0, 2, { float: true });
+  configured = applyRuntimeFlagOverrides(configured, { repeatPenalty });
+
+  // ── Batch size ─────────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Batch size", renderRows([
+    ["What it does", "Tokens processed in parallel during prompt processing (before generation)"],
+    ["Range", "1 – 4096"],
+    ["Guidance", "512: good default · 2048+: faster for long prompts · Lower if memory tight"],
+  ])));
+  const batchSize = await prompt.number("Batch size", configured.flags.batchSize, 1, 4096);
+  configured = applyRuntimeFlagOverrides(configured, { batchSize });
+
+  // ── Parallel slots ─────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Parallel slots", renderRows([
+    ["What it does", "Number of concurrent request slots (each handles an independent conversation)"],
+    ["Range", "1 – 10"],
+    ["Memory", "KV cache is multiplied by this number"],
+    ["Guidance", "1: single-user local · 2+: multiple clients connecting simultaneously"],
+  ])));
+  const parallel = await prompt.number("Parallel slots", configured.flags.parallel, 1, 10);
+  configured = applyRuntimeFlagOverrides(configured, { parallel });
+
+  // ── Flash attention ────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Flash attention", renderRows([
+    ["What it does", "Memory-efficient attention algorithm — faster and less RAM than standard"],
+    ["Guidance", "Always on for modern hardware · Turn off only for old GPU driver compat issues"],
+  ])));
+  const flashAttn = await prompt.yesNo("Enable flash attention?", true);
+  configured = applyRuntimeFlagOverrides(configured, { flashAttention: flashAttn ? "on" : "off" });
+
+  // ── Jinja templates ────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Jinja chat templates", renderRows([
+    ["What it does", "Enables Jinja2 template rendering for proper chat formatting"],
+    ["Guidance", "Always on for modern models · Turn off only for very old models without chat templates"],
+  ])));
+  const jinja = await prompt.yesNo("Enable Jinja templates?", true);
+  configured = applyRuntimeFlagOverrides(configured, { jinja });
 
+  // ── Final summary ──────────────────────────────────────────────────────
   console.log("");
-  console.log(renderSection("Defaults", renderRows([
+  console.log(renderSection("Configuration summary", renderRows([
+    ["Model", pc.bold(configured.label)],
     ["Backend", configured.backend],
     ["Endpoint", configured.baseUrl],
-    ["Temperature", configured.flags.temperature],
-    ["Top-p", configured.flags.topP],
-    ["Top-k", configured.flags.topK],
-    ["Min-p", configured.flags.minP],
-    ["Presence penalty", configured.flags.presencePenalty],
-    ["Repeat penalty", configured.flags.repeatPenalty],
+    ["Context", `${configured.flags.ctxSize.toLocaleString()} tokens`],
+    ["KV cache", `${configured.flags.cacheTypeK}/${configured.flags.cacheTypeV}`],
+    ["Temperature", String(configured.flags.temperature)],
+    ["Top-p", String(configured.flags.topP)],
+    ["Top-k", String(configured.flags.topK)],
+    ["Min-p", String(configured.flags.minP)],
+    ["Presence penalty", String(configured.flags.presencePenalty)],
+    ["Repeat penalty", String(configured.flags.repeatPenalty)],
+    ["Batch size", String(configured.flags.batchSize)],
+    ["Parallel", String(configured.flags.parallel)],
+    ["Flash attention", configured.flags.flashAttention],
+    ["Jinja", configured.flags.jinja ? "on" : "off"],
+    ...(configured.capabilities?.mtp ? [["MTP", "enabled"]] : []),
+    ...(configured.capabilities?.vision ? [["Vision", "enabled"]] : []),
+    ...(configured.capabilities?.thinking ? [["Thinking", "enabled"]] : []),
   ])));
 
-  console.log("\n" + renderMemoryEstimate(configured));
+  console.log("");
+  console.log(renderMemoryEstimate(configured));
   if (!(await prompt.yesNo("Save profile with these settings?", true))) return null;
   return configured;
 }
@@ -150,24 +298,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) {
@@ -214,10 +398,12 @@ function applyProfileFlags(profile, flags) {
 
 function renderMemoryEstimate(profile) {
   try {
-    const est = estimateMemory(profile.modelPath, profile.mmprojPath, null, profile.flags);
+    const est = estimateMemory(profile.modelPath, profile.mmprojPath, profile.drafterPath, profile.flags);
     return renderSection("Memory estimate", renderRows([
       ["Estimated total", pc.bold(`~${formatBytes(est.totalBytes)}`)],
       ["Model", formatBytes(est.modelBytes)],
+      ...(est.mmprojBytes ? [["Vision projector", formatBytes(est.mmprojBytes)]] : []),
+      ...(est.draftBytes ? [["Drafter (MTP)", formatBytes(est.draftBytes)]] : []),
       ["KV cache", est.kvBytes ? `~${formatBytes(est.kvBytes)} (${profile.flags.ctxSize.toLocaleString()} ctx, ${profile.flags.cacheTypeK}/${profile.flags.cacheTypeV})` : "unknown"],
       ...(est.note ? [["Note", pc.yellow(est.note)]] : []),
     ]));
@@ -243,8 +429,5 @@ async function runtimeSupportsGemma4Unified() {
   }
 }
 
-function samplingSummary(flags) {
-  return `temp ${flags.temperature}, top-p ${flags.topP}, top-k ${flags.topK}`;
-}
 
 

package/src/profiles.mjs

@@ -40,7 +40,15 @@ export async function loadProfiles() {
     .filter((e) => e.isDirectory() && existsSync(profileJsonPath(e.name)))
     .map((e) => e.name)
     .sort();
-  return (await Promise.all(ids.map((id) => readProfile(id)))).filter((p) => BACKENDS[p.backend]);
+  return (await Promise.all(ids.map((id) => readProfile(id))))
+    .map((p) => {
+      // Migrate legacy llama-cpp-mtp backend → llama-cpp with mtp capability
+      if (p.backend === "llama-cpp-mtp") {
+        return { ...p, backend: "llama-cpp", providerId: "llama-cpp", capabilities: { ...(p.capabilities ?? {}), mtp: true } };
+      }
+      return p;
+    })
+    .filter((p) => BACKENDS[p.backend]);
 }
 
 export async function readProfile(id) {
@@ -49,7 +57,7 @@ export async function readProfile(id) {
   return JSON.parse(await readFile(path, "utf8"));
 }
 
-export async function saveProfile(profile, options = {}) {
+export async function saveProfile(profile) {
   const id = sanitizeProfileId(profile.id);
   const dir = profileDir(id);
   await mkdir(dir, { recursive: true });
@@ -126,7 +134,7 @@ export async function createProfileFromModel(model, backendId, drafterPath) {
   const caps = detectCapabilities(model.path, model.mmprojPath);
   // If a drafter is provided, this model supports MTP regardless of filename
   const hasMtp = caps.mtp || Boolean(drafterPath);
-  const backend = backendId ?? (hasMtp ? "llama-cpp-mtp" : "llama-cpp");
+  const backend = backendId ?? "llama-cpp";
   const { flags } = computeFlags(
     { ...caps, mtp: hasMtp },
     model.path,

package/src/ui.mjs

@@ -95,36 +95,18 @@ export function renderCard(title, body, options = {}) {
   }
 
   const topTitle = title ? `╭${pc.reset(titleStr)}` : "╭";
-  const topFill = "─".repeat(Math.max(0, width + 2 - visibleLen(titleStr)));
+  const topFill = "─".repeat(Math.max(0, width - visibleLen(titleStr)));
   const top = `${topTitle}${topFill}╮`;
 
   const middle = lines.map((line) => `│ ${padVisible(line, contentWidth)} │`);
 
-  const bottom = `╰${"─".repeat(width + 2)}╯`;
+  const bottom = `╰${"─".repeat(width)}╯`;
 
   return [top, ...middle, bottom].map((l) => borderColor(l)).join("\n");
 }
 
 function wrapVisible(text, width) {
-  const words = String(text).split(/(\s+)/u);
-  const lines = [];
-  let current = "";
-  for (let word of words) {
-    // If a single word exceeds the width, hard-break it
-    while (visibleLen(word) > width) {
-      if (current.trim()) { lines.push(current.trimEnd()); current = ""; }
-      lines.push(word.slice(0, width));
-      word = word.slice(width);
-    }
-    if (visibleLen(current + word) > width && current.trim()) {
-      lines.push(current.trimEnd());
-      current = word.trimStart();
-    } else {
-      current += word;
-    }
-  }
-  if (current.trim()) lines.push(current.trimEnd());
-  return lines.length > 0 ? lines : [text];
+  return wrapText(text, width);
 }
 
 export function renderSectionRows(title, rows, options = {}) {
@@ -198,9 +180,8 @@ async function runPrompt(fn, config) {
 
 // ── Interactive prompt factory ──────────────────────────────────────────────
 
-export function startInteractive(title = "offgrid-ai") {
+export function startInteractive() {
   if (process.stdin.isTTY) console.clear();
-  console.log(pc.magenta(`◆ ${title}`));
 }
 
 export function createPrompt() {
@@ -213,14 +194,18 @@ export function createPrompt() {
       return value?.trim() || String(defaultValue ?? "");
     },
 
-    async number(label, defaultValue, min, max) {
+    async number(label, defaultValue, min, max, { float = false } = {}) {
       const value = await runPrompt(number, {
         message: label,
         default: defaultValue,
+        min,
+        max,
+        step: float ? 'any' : 1,
         validate(input) {
           if (!Number.isFinite(input) || input < min || input > max) {
             return `Enter a number from ${min} to ${max}.`;
           }
+          return true;
         },
       });
       return Number(value);
@@ -252,12 +237,10 @@ export function createPrompt() {
 
 export async function modelSelect(label, groups, { defaultKey, pageSize = 20 } = {}) {
   const choices = [];
-  // Separator below the prompt message
-  choices.push(new Separator(pc.dim("  ────────────────────────────────────────────────────────────")));
   for (let i = 0; i < groups.length; i++) {
     const group = groups[i];
     // Add blank line before each group (except the first)
-    if (i > 0) choices.push(new Separator(""));
+    if (i > 0) choices.push(new Separator(" "));
     if (group.separator) {
       choices.push(new Separator(group.separator));
     }