offgrid-ai 0.9.2 → 0.9.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "offgrid-ai",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "Privacy-first CLI for running local LLMs — discover, configure, run, benchmark",
   "author": "Eeshan Srivastava (https://eeshans.com)",
   "type": "module",

package/src/backends.mjs

@@ -143,7 +143,7 @@ function isLocalOllamaModel(model) {
 function isChatOmlxModel(model) {
   if (typeof model?.id !== "string" || !model.id.trim()) return false;
   const type = String(model.type ?? model.model_type ?? "").toLowerCase();
-  if (["embedding", "embeddings", "reranker", "tool", "converter"].includes(type)) return false;
+  if (["embedding", "embeddings", "reranker", "tool", "converter", "markitdown"].includes(type)) return false;
   if (Object.hasOwn(model, "max_model_len") && model.max_model_len === null) return false;
   return true;
 }

package/src/benchmark/finalize.mjs

@@ -1,7 +1,7 @@
 // ── Unload model from server memory after benchmark ────────────────────────────
 
 import { backendFor } from "../backends.mjs";
-import { apiRootUrl } from "../process.mjs";
+import { apiRootUrl, serverModelIds } from "../process.mjs";
 import { existsSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
@@ -33,14 +33,62 @@ export async function unloadModelFromServer(profile) {
   }
 
   if (backend.id === "omlx") {
-    // oMLX does not expose a model-unload endpoint. The model stays resident
-    // until the oMLX server process is stopped.
-    return { unloaded: false, backend: backend.id, reason: "no unload API available" };
+    return await unloadOmlxModel(profile);
   }
 
   return { unloaded: false, backend: backend.id, reason: "unsupported backend" };
 }
 
+async function unloadOmlxModel(profile) {
+  const baseUrl = profile.baseUrl?.replace(/\/v1\/?$/u, "") || "";
+  const adminUrl = `${baseUrl}/admin/api/models`;
+  const modelId = profile.modelAlias || profile.omlxModel || profile.id;
+
+  try {
+    const ids = await serverModelIds(profile.baseUrl);
+    const match = ids.find((id) => id.toLowerCase() === modelId.toLowerCase());
+    const targetId = match ?? modelId;
+
+    const response = await fetch(`${adminUrl}/${encodeURIComponent(targetId)}/unload`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      signal: AbortSignal.timeout(30000),
+    });
+
+    if (response.ok) {
+      return { unloaded: true, backend: "omlx", modelId: targetId };
+    }
+
+    let detail = "";
+    try {
+      const body = await response.json();
+      detail = body?.detail ?? body?.message ?? "";
+    } catch {
+      detail = await response.text().catch(() => "");
+    }
+
+    if (response.status === 400 && /not loaded/i.test(detail)) {
+      return { unloaded: true, backend: "omlx", modelId: targetId, reason: "model was not loaded" };
+    }
+
+    if (response.status === 401 || response.status === 403) {
+      return {
+        unloaded: false,
+        backend: "omlx",
+        modelId: targetId,
+        error: "oMLX admin authentication required. Enable skip_api_key_verification in oMLX settings, or unload manually from the admin panel.",
+      };
+    }
+
+    return { unloaded: false, backend: "omlx", modelId: targetId, error: `HTTP ${response.status}: ${detail}` };
+  } catch (err) {
+    if (err?.name === "AbortError" || err?.name === "TimeoutError") {
+      return { unloaded: false, backend: "omlx", modelId, error: "Unload request timed out. The model may still be unloading in the background." };
+    }
+    return { unloaded: false, backend: "omlx", modelId, error: err.message };
+  }
+}
+
 export async function finalizeBenchmarkRun(runDirectory, runResult, speedMetrics) {
   const metadataPath = join(runDirectory, "metadata.json");
   const metadata = JSON.parse(await readFile(metadataPath, "utf8"));

package/src/benchmark/pi-runner.mjs

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { spawn } from "node:child_process";
 import {
   BENCH_COLORS, renderStreamEvent,
-  formatToolCall,
+  formatToolCall, printFinalLine,
 } from "./stream-renderer.mjs";
 import { piModelString } from "./shared.mjs";
 
@@ -212,6 +212,8 @@ export async function runBenchmarkInPi(profile, runDirectory, { signal } = {}) {
         return;
       }
 
+      printFinalLine(BENCH_COLORS.info("Pi benchmark finished"));
+
       if (runResult.exitCode !== 0) {
         runResult.error = { message: `Pi exited with code ${runResult.exitCode}` };
         resolve(runResult);

package/src/benchmark/stream-renderer.mjs

@@ -142,7 +142,6 @@ export function renderStreamEvent(parsed, state, opts = {}) {
     }
     case "agent_end":
       clearStatusLine();
-      printFinalLine(BENCH_COLORS.info("Pi benchmark finished"));
       break;
     default:
       break;

package/src/commands/run.mjs

@@ -2,7 +2,7 @@ import { existsSync } from "node:fs";
 import { ensureDirs } from "../config.mjs";
 import { backendFor } from "../backends.mjs";
 import { normalizeProfile, readProfile, saveProfile } from "../profiles.mjs";
-import { startServer, stopProfile, waitForReady, serverReady, serverMatchesProfile } from "../process.mjs";
+import { startServer, stopProfile, waitForReady, serverReady, serverMatchesProfile, modelAvailableOnServer } from "../process.mjs";
 import { syncPiConfig, hasPiModel, launchPi, hasPi } from "../harness-pi.mjs";
 import { tailFriendly } from "../logs.mjs";
 import { estimateMemory } from "../estimate.mjs";
@@ -33,6 +33,11 @@ export async function runProfile(profile, options = {}) {
     if (!(await serverReady(profile.baseUrl))) {
       throw new Error(`${backend.label} is not running at ${profile.baseUrl}. Start it and try again.`);
     }
+    const available = await modelAvailableOnServer(profile);
+    if (!available) {
+      const modelId = profile.omlxModel ?? profile.ollamaModel ?? profile.modelAlias ?? profile.label;
+      throw new Error(`${modelId} is not available on ${backend.label} at ${profile.baseUrl}.`);
+    }
     console.log(pc.green(`[ready] ${backend.label} at ${profile.baseUrl}`));
   } else {
     const startup = await ensureLocalServer(profile, backend, options);

package/src/commands/status.mjs

@@ -13,17 +13,48 @@ export async function statusCommand() {
   }
 
   const running = statuses.filter((item) => item.status.running);
-  if (running.length === 0) {
-    console.log(renderCard("Status", renderRows([
-      ["Running now", pc.dim("none")],
-      ["Ready setups", profiles.length > 0 ? String(profiles.length) : pc.dim("none")],
-      ["Next step", profiles.length > 0 ? "Run offgrid-ai to start chatting" : pc.yellow("Run offgrid-ai to set up a model")],
-    ]), { formatBorder: pc.dim }));
-    return;
+  const managedUpMissing = statuses.filter((item) => {
+    const backend = backendFor(item.profile.backend);
+    return backend.type === "managed-server" && item.status.serverUp && !item.status.modelAvailable;
+  });
+  const managedUpNotLoaded = statuses.filter((item) => {
+    const backend = backendFor(item.profile.backend);
+    return backend.type === "managed-server" && item.status.serverUp && item.status.modelAvailable && !item.status.modelLoaded;
+  });
+
+  const summaryRows = [
+    ["Running now", running.length > 0 ? pc.green(`${running.length} model${running.length === 1 ? "" : "s"}`) : pc.dim("none")],
+    ["Ready setups", profiles.length > 0 ? String(profiles.length) : pc.dim("none")],
+  ];
+
+  if (managedUpMissing.length > 0) {
+    summaryRows.push(["Server up, model missing", pc.yellow(String(managedUpMissing.length))]);
+  }
+  if (managedUpNotLoaded.length > 0) {
+    summaryRows.push(["Server up, model not loaded", pc.yellow(String(managedUpNotLoaded.length))]);
+  }
+
+  summaryRows.push(["Next step", profiles.length > 0 ? "Run offgrid-ai to start chatting" : pc.yellow("Run offgrid-ai to set up a model")]);
+
+  console.log(renderCard("Status", renderRows(summaryRows), { formatBorder: running.length > 0 ? pc.green : pc.dim }));
+
+  if (managedUpMissing.length > 0 || managedUpNotLoaded.length > 0) {
+    const detailRows = [];
+    for (const { profile, status } of [...managedUpMissing, ...managedUpNotLoaded]) {
+      const backend = backendFor(profile.backend);
+      const modelId = profile.omlxModel ?? profile.ollamaModel ?? profile.modelAlias ?? profile.id;
+      const state = status.modelAvailable
+        ? pc.yellow("server up · model not loaded")
+        : pc.red("server up · model missing");
+      detailRows.push([`${profile.label} (${modelId})`, state]);
+      detailRows.push(["Server", `${backend.label} at ${profile.baseUrl}`]);
+    }
+    console.log("\n" + renderCard("Managed servers", renderRows(detailRows), { formatBorder: pc.yellow }));
   }
 
-  console.log(renderCard("Status", renderRows([
-    ["Running now", pc.green(`${running.length} model${running.length === 1 ? "" : "s"}`)],
+  if (running.length === 0) return;
+
+  console.log("\n" + renderCard("Running", renderRows([
     ["Stop", "offgrid-ai stop"],
   ]), { formatBorder: pc.green }));
   for (const { profile, status } of running) {

package/src/process.mjs

@@ -132,12 +132,27 @@ export async function modelLoadedOnServer(profile) {
   return matches;
 }
 
+export async function modelAvailableOnServer(profile) {
+  const backend = backendFor(profile.backend);
+  if (backend.id === "ollama") {
+    return modelIdsMatch(await ollamaAvailableModelIds(profile), expectedModelIds(profile));
+  }
+  if (backend.id === "omlx") {
+    // /v1/models lists discovered models; an ID must exist there to be usable.
+    return modelIdsMatch(await serverModelIds(profile.baseUrl), expectedModelIds(profile));
+  }
+  // Local servers are tied to a specific model file via their command argv.
+  return true;
+}
+
 export async function profileRuntimeStatus(profile) {
   const backend = backendFor(profile.backend);
   if (backend.type === "managed-server") {
     const ready = await serverReady(profile.baseUrl);
-    const modelLoaded = ready ? await modelLoadedOnServer(profile) : false;
-    return { state: null, pid: null, running: ready && modelLoaded, ready, serverUp: ready, modelLoaded, rssBytes: null, startedAt: null };
+    const [modelLoaded, modelAvailable] = ready
+      ? await Promise.all([modelLoadedOnServer(profile), modelAvailableOnServer(profile)])
+      : [false, false];
+    return { state: null, pid: null, running: ready && modelLoaded, ready, serverUp: ready, modelLoaded, modelAvailable, rssBytes: null, startedAt: null };
   }
   const state = await readState(profile.id);
   const running = Boolean(state?.pid && pidAlive(state.pid));
@@ -194,7 +209,7 @@ export async function waitForReady(profile, pid, rawLogPath) {
 
 // ── Internals ──────────────────────────────────────────────────────────────
 
-async function serverModelIds(baseUrl) {
+export async function serverModelIds(baseUrl) {
   const result = await fetchJson(`${baseUrl.replace(/\/+$/u, "")}/models`);
   if (!result.ok) return [];
   return (Array.isArray(result.data?.data) ? result.data.data : [])
@@ -211,6 +226,15 @@ async function ollamaLoadedModelIds(profile) {
     .filter(Boolean);
 }
 
+async function ollamaAvailableModelIds(profile) {
+  const result = await fetchJson(`${apiRootUrl(profile.baseUrl)}/api/tags`);
+  if (!result.ok) return [];
+  return (Array.isArray(result.data?.models) ? result.data.models : [])
+    .flatMap((model) => [model?.name, model?.model])
+    .map((id) => String(id ?? "").trim())
+    .filter(Boolean);
+}
+
 async function omlxLoadedModelIds(profile) {
   const statusResult = await fetchJson(`${profile.baseUrl.replace(/\/+$/u, "")}/models/status`);
   const fromStatus = statusResult.ok