fix(onboard): offer Ollama upgrade when host version too old

docs/inference/use-local-inference.mdx

@@ -31,6 +31,7 @@ The onboard wizard detects Ollama automatically when it is installed or running
 
 If Ollama is installed but not running, NemoClaw starts it for you.
 On macOS and Linux, the wizard can also offer to install Ollama when it is not present.
+When the host Ollama is below the minimum version NemoClaw expects for its starter models (currently `0.7.0`), the wizard surfaces an explicit **Upgrade Ollama** entry in the provider menu instead of silently reusing the older daemon, and the express setup path resolves to that entry so it runs the platform's install/upgrade path: `brew upgrade ollama` on macOS, the official `https://ollama.com/install.sh` on Linux.
 On WSL, the wizard can use, start, restart, or install Ollama on the Windows host through PowerShell interop.
 
 #### Linux Install Modes

src/lib/inference/local.ts

@@ -78,6 +78,12 @@ export const QWEN3_6_OLLAMA_MODEL = assertRegistryTag("qwen3.6:35b");
 
 export type RunCaptureFn = (cmd: string | string[], opts?: { ignoreError?: boolean }) => string;
 
+export {
+  getInstalledOllamaVersion,
+  isOllamaVersionAtLeast,
+  MIN_OLLAMA_VERSION,
+} from "./ollama-version";
+
 export type RunCaptureExFn = (cmd: string[]) => CaptureResult;
 
 // Hosts that the WSL-side onboard CLI tries when probing Ollama. Native Linux

src/lib/inference/ollama-version.test.ts

@@ -0,0 +1,51 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { describe, expect, it } from "vitest";
+
+import {
+  getInstalledOllamaVersion,
+  isOllamaVersionAtLeast,
+  MIN_OLLAMA_VERSION,
+} from "../../../dist/lib/inference/ollama-version";
+
+describe("Ollama version detection", () => {
+  it("parses 'ollama version is X.Y.Z' output", () => {
+    const capture = () => "ollama version is 0.6.2";
+    expect(getInstalledOllamaVersion(capture)).toBe("0.6.2");
+  });
+
+  it("returns null when ollama --version produces no output", () => {
+    const capture = () => "";
+    expect(getInstalledOllamaVersion(capture)).toBeNull();
+  });
+
+  it("returns null when ollama --version output has no version", () => {
+    const capture = () => "ollama: command not found";
+    expect(getInstalledOllamaVersion(capture)).toBeNull();
+  });
+
+  it("treats null/missing versions as below the minimum", () => {
+    expect(isOllamaVersionAtLeast(null, MIN_OLLAMA_VERSION)).toBe(false);
+  });
+
+  it("treats 0.6.2 as below the 0.7.0 floor", () => {
+    expect(isOllamaVersionAtLeast("0.6.2", "0.7.0")).toBe(false);
+  });
+
+  it("treats 0.7.0 as meeting the 0.7.0 floor", () => {
+    expect(isOllamaVersionAtLeast("0.7.0", "0.7.0")).toBe(true);
+  });
+
+  it("treats 0.24.0 as above the 0.7.0 floor", () => {
+    expect(isOllamaVersionAtLeast("0.24.0", "0.7.0")).toBe(true);
+  });
+
+  it("treats 1.0.0 as above the 0.7.0 floor", () => {
+    expect(isOllamaVersionAtLeast("1.0.0", "0.7.0")).toBe(true);
+  });
+
+  it("returns false for unparseable version components", () => {
+    expect(isOllamaVersionAtLeast("not-a-version", "0.7.0")).toBe(false);
+  });
+});

src/lib/inference/ollama-version.ts

@@ -0,0 +1,51 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Ollama version detection helpers. Kept separate from the larger
+ * `inference/local.ts` so the version-floor logic can evolve without
+ * dragging the rest of the local-inference helpers along.
+ */
+
+const { runCapture } = require("../runner");
+
+export type OllamaVersionRunCapture = (
+  cmd: string | string[],
+  opts?: { ignoreError?: boolean },
+) => string;
+
+/**
+ * Minimum Ollama version NemoClaw expects when reusing an existing host
+ * Ollama. Older Ollama runners crash loading newer starter models because
+ * their GGUF parsers predate the model format. Bump this when starter-model
+ * recipes adopt a newer GGUF feature.
+ */
+export const MIN_OLLAMA_VERSION = "0.7.0";
+
+export function getInstalledOllamaVersion(
+  runCaptureImpl?: OllamaVersionRunCapture,
+): string | null {
+  const capture = runCaptureImpl ?? runCapture;
+  const out = capture(["ollama", "--version"], { ignoreError: true });
+  if (!out) return null;
+  const match = out.match(/(\d+)\.(\d+)\.(\d+)/);
+  return match ? match[0] : null;
+}
+
+export function isOllamaVersionAtLeast(
+  version: string | null,
+  minimum: string,
+): boolean {
+  if (!version) return false;
+  const parts = version.split(".").map((v) => Number.parseInt(v, 10));
+  const min = minimum.split(".").map((v) => Number.parseInt(v, 10));
+  const len = Math.max(parts.length, min.length);
+  for (let i = 0; i < len; i += 1) {
+    const a = parts[i] ?? 0;
+    const b = min[i] ?? 0;
+    if (Number.isNaN(a) || Number.isNaN(b)) return false;
+    if (a > b) return true;
+    if (a < b) return false;
+  }
+  return true;
+}

src/lib/onboard.ts

@@ -183,6 +183,7 @@ const {
   validateOllamaModel,
   validateLocalProvider,
 } = localInference;
+const { resolveOllamaInstallMenuEntry } = require("./onboard/ollama-install-menu");
 const {
   ensureOllamaAuthProxy,
   getOllamaProxyToken,
@@ -4219,7 +4220,10 @@ async function selectAndValidateOllamaModel(
       },
     );
     if (validation.retry === "selection") return { outcome: "back-to-selection" };
-    if (!validation.ok) continue;
+    if (!validation.ok) {
+      if (isNonInteractive()) process.exit(1);
+      continue;
+    }
     // Ollama's /v1/responses endpoint does not produce correctly formatted
     // tool calls — force chat completions like vLLM/NIM.
     if (validation.api !== "openai-completions") {
@@ -4375,19 +4379,14 @@ async function setupNim(
       label: "Install Ollama on Windows host (recommended)",
     });
   }
-  // Without any Ollama, offer to install one locally as a fallback (e.g. when
-  // the NVIDIA API server is down and cloud keys are unavailable).
-  if (!hasOllama && !ollamaRunning && !hasWindowsOllama) {
-    if (process.platform === "darwin") {
-      options.push({ key: "install-ollama", label: "Install Ollama (macOS)" });
-    } else if (process.platform === "linux") {
-      if (isWsl()) {
-        options.push({ key: "install-ollama", label: "Install Ollama (WSL Linux)" });
-      } else {
-        options.push({ key: "install-ollama", label: "Install Ollama (Linux)" });
-      }
-    }
-  }
+  const ollamaInstallMenu = resolveOllamaInstallMenuEntry({
+    hasOllama,
+    ollamaRunning,
+    hasWindowsOllama,
+    platform: process.platform,
+    isWsl: isWsl(),
+  });
+  if (ollamaInstallMenu.entry) options.push(ollamaInstallMenu.entry);
 
   // Model Router: complexity-based routing via blueprint config.
   const blueprintRouterCfg = loadBlueprintProfile("routed");
@@ -5266,8 +5265,9 @@ async function setupNim(
       } else if (selected.key === "install-ollama") {
         if (!checkOllamaPortsOrWarn()) continue selectionLoop;
         if (process.platform === "darwin") {
-          console.log("  Installing Ollama via Homebrew...");
-          run(["brew", "install", "ollama"], { ignoreError: true });
+          const brewAction = ollamaInstallMenu.hasUpgradableOllama ? "upgrade" : "install";
+          console.log(`  ${brewAction === "upgrade" ? "Upgrading" : "Installing"} Ollama via Homebrew...`);
+          run(["brew", brewAction, "ollama"], { ignoreError: true });
           // brew install doesn't auto-start a service; launch directly.
           // Shell required: backgrounding (&), env var prefix, output redirection.
           console.log("  Starting Ollama...");

src/lib/onboard/ollama-install-menu.test.ts

@@ -0,0 +1,127 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { describe, expect, it } from "vitest";
+
+import { resolveOllamaInstallMenuEntry } from "../../../dist/lib/onboard/ollama-install-menu";
+import { MIN_OLLAMA_VERSION } from "../../../dist/lib/inference/ollama-version";
+
+const LINUX_NON_WSL = { platform: "linux" as const, isWsl: false };
+
+describe("resolveOllamaInstallMenuEntry", () => {
+  it("offers a fresh install when no Ollama is present", () => {
+    const result = resolveOllamaInstallMenuEntry({
+      hasOllama: false,
+      ollamaRunning: false,
+      hasWindowsOllama: false,
+      installedOllamaVersion: null,
+      ...LINUX_NON_WSL,
+    });
+    expect(result.hasUpgradableOllama).toBe(false);
+    expect(result.entry?.key).toBe("install-ollama");
+    expect(result.entry?.label).toBe("Install Ollama (Linux)");
+  });
+
+  it("offers an upgrade entry when host Ollama is below the minimum", () => {
+    const result = resolveOllamaInstallMenuEntry({
+      hasOllama: true,
+      ollamaRunning: true,
+      hasWindowsOllama: false,
+      installedOllamaVersion: "0.6.2",
+      ...LINUX_NON_WSL,
+    });
+    expect(result.hasUpgradableOllama).toBe(true);
+    expect(result.entry?.key).toBe("install-ollama");
+    expect(result.entry?.label).toBe(
+      `Upgrade Ollama (Linux) — upgrade installed 0.6.2 to ≥ ${MIN_OLLAMA_VERSION}`,
+    );
+  });
+
+  it("omits the entry when host Ollama meets the minimum", () => {
+    const result = resolveOllamaInstallMenuEntry({
+      hasOllama: true,
+      ollamaRunning: true,
+      hasWindowsOllama: false,
+      installedOllamaVersion: "0.24.0",
+      ...LINUX_NON_WSL,
+    });
+    expect(result.hasUpgradableOllama).toBe(false);
+    expect(result.entry).toBeNull();
+  });
+
+  it("omits the entry when only Windows-host Ollama is present", () => {
+    const result = resolveOllamaInstallMenuEntry({
+      hasOllama: false,
+      ollamaRunning: false,
+      hasWindowsOllama: true,
+      installedOllamaVersion: null,
+      ...LINUX_NON_WSL,
+    });
+    expect(result.entry).toBeNull();
+  });
+
+  it("treats null versions as below the minimum to recover stale installs", () => {
+    const result = resolveOllamaInstallMenuEntry({
+      hasOllama: true,
+      ollamaRunning: true,
+      hasWindowsOllama: false,
+      installedOllamaVersion: null,
+      ...LINUX_NON_WSL,
+    });
+    expect(result.hasUpgradableOllama).toBe(true);
+    expect(result.entry?.label).toBe(
+      `Upgrade Ollama (Linux) — upgrade installed unknown to ≥ ${MIN_OLLAMA_VERSION}`,
+    );
+  });
+
+  it("labels WSL Linux distinctly when the host is WSL", () => {
+    const result = resolveOllamaInstallMenuEntry({
+      hasOllama: false,
+      ollamaRunning: false,
+      hasWindowsOllama: false,
+      installedOllamaVersion: null,
+      platform: "linux",
+      isWsl: true,
+    });
+    expect(result.entry?.label).toBe("Install Ollama (WSL Linux)");
+  });
+
+  it("labels macOS distinctly", () => {
+    const result = resolveOllamaInstallMenuEntry({
+      hasOllama: false,
+      ollamaRunning: false,
+      hasWindowsOllama: false,
+      installedOllamaVersion: null,
+      platform: "darwin",
+      isWsl: false,
+    });
+    expect(result.entry?.label).toBe("Install Ollama (macOS)");
+  });
+
+  it("labels macOS upgrade case so the Homebrew branch can pick brew upgrade", () => {
+    const result = resolveOllamaInstallMenuEntry({
+      hasOllama: true,
+      ollamaRunning: true,
+      hasWindowsOllama: false,
+      installedOllamaVersion: "0.6.2",
+      platform: "darwin",
+      isWsl: false,
+    });
+    expect(result.hasUpgradableOllama).toBe(true);
+    expect(result.entry?.label).toBe(
+      `Upgrade Ollama (macOS) — upgrade installed 0.6.2 to ≥ ${MIN_OLLAMA_VERSION}`,
+    );
+  });
+
+  it("does not return an entry on unsupported platforms", () => {
+    const result = resolveOllamaInstallMenuEntry({
+      hasOllama: false,
+      ollamaRunning: false,
+      hasWindowsOllama: false,
+      installedOllamaVersion: null,
+      platform: "win32",
+      isWsl: false,
+    });
+    expect(result.entry).toBeNull();
+  });
+});

src/lib/onboard/ollama-install-menu.ts

@@ -0,0 +1,75 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+  getInstalledOllamaVersion,
+  isOllamaVersionAtLeast,
+  MIN_OLLAMA_VERSION,
+} from "../inference/ollama-version";
+
+export interface OllamaInstallMenuInput {
+  hasOllama: boolean;
+  ollamaRunning: boolean;
+  hasWindowsOllama: boolean;
+  platform: NodeJS.Platform;
+  isWsl: boolean;
+  /** Override for tests. Defaults to a live `ollama --version` probe. */
+  installedOllamaVersion?: string | null;
+}
+
+export interface OllamaInstallMenuEntry {
+  key: "install-ollama";
+  label: string;
+}
+
+export interface OllamaInstallMenuResult {
+  entry: OllamaInstallMenuEntry | null;
+  hasUpgradableOllama: boolean;
+}
+
+function osTagFor(platform: NodeJS.Platform, isWsl: boolean): string | null {
+  if (platform === "darwin") return "macOS";
+  if (platform === "linux") return isWsl ? "WSL Linux" : "Linux";
+  return null;
+}
+
+/**
+ * Decide whether the onboard provider menu should expose an `install-ollama`
+ * entry, and which label to render. Two cases:
+ *
+ *   1. No Ollama anywhere (host, running, or Windows) — offer a fresh install
+ *      as a fallback (e.g. when the NVIDIA API server is down and cloud keys
+ *      are unavailable).
+ *   2. Host Ollama exists but its version is below `MIN_OLLAMA_VERSION` —
+ *      offer an explicit upgrade so the express setup path doesn't reuse a
+ *      daemon that crashes loading newer starter models.
+ */
+export function resolveOllamaInstallMenuEntry(
+  input: OllamaInstallMenuInput,
+): OllamaInstallMenuResult {
+  const installedOllamaVersion =
+    input.installedOllamaVersion !== undefined
+      ? input.installedOllamaVersion
+      : input.hasOllama
+        ? getInstalledOllamaVersion()
+        : null;
+  const hasUpgradableOllama =
+    input.hasOllama && !isOllamaVersionAtLeast(installedOllamaVersion, MIN_OLLAMA_VERSION);
+  const showEntry =
+    (!input.hasOllama && !input.ollamaRunning && !input.hasWindowsOllama) || hasUpgradableOllama;
+  if (!showEntry) {
+    return { entry: null, hasUpgradableOllama };
+  }
+  const osTag = osTagFor(input.platform, input.isWsl);
+  if (osTag === null) {
+    return { entry: null, hasUpgradableOllama };
+  }
+  const labelPrefix = hasUpgradableOllama ? "Upgrade Ollama" : "Install Ollama";
+  const upgradeSuffix = hasUpgradableOllama
+    ? ` — upgrade installed ${installedOllamaVersion ?? "unknown"} to ≥ ${MIN_OLLAMA_VERSION}`
+    : "";
+  return {
+    entry: { key: "install-ollama", label: `${labelPrefix} (${osTag})${upgradeSuffix}` },
+    hasUpgradableOllama,
+  };
+}