pi-llama-cpp 0.12.0 → 0.13.0

package/README.md

@@ -32,6 +32,16 @@ A [Pi Coding Agent](https://pi.dev/) extension that integrates with running [lla
 
 > **Note:** You can run your server with API authentication with `llama-server --api-key <your key> ...`.
 
+### Server Health Indicators
+
+When browsing servers via `/models servers`, each server URL is prefixed with a health indicator:
+
+| Icon | Status      | Description                                   |
+| ---- | ----------- | --------------------------------------------- |
+| 🟢   | Healthy     | Server responded successfully to health check |
+| 🟡   | Timeout     | Server health check timed out                 |
+| 🔴   | Unreachable | Server could not be reached                   |
+
 ## Installation
 
 This package is a Pi extension. Install it with
@@ -128,7 +138,9 @@ Run `/models settings` to edit the scalar settings above without hand-editing JS
 #### Server list editor
 
 Run `/models servers` to add, edit or remove entries of `llamaSettings.servers`
-without hand-editing JSON. Each change is written immediately to the **project**
+without hand-editing JSON. Each server URL is prefixed with a health indicator
+(🟢 healthy, 🟡 timeout, 🔴 unreachable) that reflects the result of a
+health check against the server. Each change is written immediately to the **project**
 `.pi/settings.json` if it exists, otherwise to **global**
 `~/.pi/agent/settings.json`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-llama-cpp",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Pi extension for llama.cpp integration. Supports router, single and legacy models. Supports multiple servers.",
   "keywords": [
     "pi",
@@ -40,6 +40,6 @@
   "devDependencies": {
     "@types/node": "^26.4.1",
     "prettier-plugin-organize-imports": "^4.3.0",
-    "vitest": "^5.0.0"
+    "vitest": "^5.0.1"
   }
 }

package/src/constants.ts

@@ -28,6 +28,14 @@ export const API_KEY_PLACEHOLDER = "sk-placeholder";
  */
 export const LLAMA_SERVER_URL = "http://127.0.0.1:8080";
 
+/**
+ * Endpoint prefix of the OpenAI-compatible API exposed by llama-server.
+ * Native routes (/health, /props, /models/sse, ...) live directly under the
+ * server root; only OpenAI-dialect consumers (the Pi provider registration
+ * and the /models listing) address the API under this prefix.
+ */
+export const ENDPOINT_PREFIX = "/v1";
+
 /**
  * The default context if the server didn't expose it
  */

package/src/interfaces/settings.ts

@@ -43,7 +43,8 @@ export interface ModelOverride {
  */
 export interface LlamaServer {
   /**
-   * The URL of the llama.cpp server.
+   * The URL of the llama.cpp server. Must be the bare origin — the
+   * OpenAI-compatible API is assumed under `/v1` (see {@link ENDPOINT_PREFIX}).
    */
   url: string;
   /**

package/src/managers/command.ts

@@ -318,6 +318,7 @@ export class CommandManager {
     }
 
     const servers = await this.settings.getLlamaServers();
+    const { serverTimeout } = await this.settings.resolveTimeouts();
 
     await ctx.ui.custom<void>(
       (tui, theme, keybindings, done) =>
@@ -333,6 +334,7 @@ export class CommandManager {
             this.serverManager.update(pi);
           },
           onError: (message) => ctx.ui.notify(message, "error"),
+          serverTimeout,
         }),
     );
   }

package/src/managers/server.ts

@@ -133,7 +133,7 @@ export class ServerManager {
    * @param server The server
    */
   private async registerProvider(server: Server, pi: ExtensionAPI) {
-    const { baseUrl, models, providerId, providerName } = server;
+    const { apiBaseUrl, models, providerId, providerName } = server;
     const apiKey = server.getApiKey();
     const modelConfigs = await Promise.all(
       models.map((m) => m.toProviderConfig()),
@@ -141,7 +141,7 @@ export class ServerManager {
 
     pi.registerProvider(providerId, {
       name: providerName,
-      baseUrl: baseUrl,
+      baseUrl: apiBaseUrl,
       api: API_TYPE,
       apiKey: apiKey,
       models: modelConfigs,

package/src/server.ts

@@ -1,6 +1,7 @@
 import { ApiClient } from "./api/client";
 import {
   API_KEY_PLACEHOLDER,
+  ENDPOINT_PREFIX,
   PROVIDER_NAME,
   PROVIDER_PREFIX,
 } from "./constants";
@@ -20,6 +21,7 @@ import { LegacyModel } from "./models/legacyModel";
 import { RouterModel } from "./models/routerModel";
 import { SingleModel } from "./models/singleModel";
 import { SSEManager } from "./sse/manager";
+import { checkServerHealth } from "./utils/health";
 
 /**
  * Optional constructor collaborators for {@link Server} — the seam tests use
@@ -59,6 +61,19 @@ export class Server {
     return this.options.baseUrl;
   }
 
+  /**
+   * Base URL of the OpenAI-compatible API: {@link baseUrl} joined with
+   * {@link ENDPOINT_PREFIX}. Idempotent — a baseUrl that already ends with
+   * the prefix is returned untouched, so proxied setups exposing the API
+   * under a /v1 path don't double up.
+   */
+  get apiBaseUrl(): string {
+    const { baseUrl } = this.options;
+    return baseUrl.endsWith(ENDPOINT_PREFIX)
+      ? baseUrl
+      : `${baseUrl}${ENDPOINT_PREFIX}`;
+  }
+
   /**
    * Maximum time (ms) for server verification and SSE support probe.
    * Resolved live from the injected settings manager.
@@ -163,28 +178,16 @@ export class Server {
   /**
    * Checks if the server is ready, with a timeout.
    *
+   * Delegates to the shared health probe (`utils/health`) — bypasses the
+   * `ApiClient` on purpose: each caller probes once per scan, so the
+   * client's cache/dedup would be dead weight, and a plain `fetch` with
+   * `AbortSignal.timeout` actually cancels the request on timeout.
+   *
    * @param timeout Maximum time to wait for the health check
    * @returns The server status
    */
   async isReady(timeout: number): Promise<ServerStatus> {
-    try {
-      const timeoutPromise = new Promise<never>((_, reject) =>
-        setTimeout(() => reject(new Error("timeout")), timeout),
-      );
-      const health = await Promise.race([
-        this.fetchServerHealth(),
-        timeoutPromise,
-      ]);
-      if (health.status === "ok") {
-        return ServerStatus.READY;
-      }
-      return ServerStatus.UNREACHABLE;
-    } catch (error) {
-      if (error instanceof Error && error.message === "timeout") {
-        return ServerStatus.TIMEOUT;
-      }
-      return ServerStatus.UNREACHABLE;
-    }
+    return checkServerHealth(this.baseUrl, timeout, this.getApiKey());
   }
 
   /**
@@ -202,7 +205,9 @@ export class Server {
    * @return The models from the server
    */
   async fetchModels(): Promise<ModelsEndpoint> {
-    return await this.apiClient.get<ModelsEndpoint>("/v1/models");
+    return await this.apiClient.get<ModelsEndpoint>(
+      `${ENDPOINT_PREFIX}/models`,
+    );
   }
 
   /**

package/src/ui/dialog.ts

@@ -167,6 +167,10 @@ export class InputDialog extends BaseDialog {
 
   /**
    * Builds a `SettingItem.submenu` factory that opens an `InputDialog`.
+   * The dialog prefills from the `currentValue` the containing
+   * `SettingsList` passes at activation time — not a value captured at
+   * build time — so re-entering a field after a commit shows the
+   * just-saved value.
    */
   static inputSubmenu =
     (
@@ -175,11 +179,10 @@ export class InputDialog extends BaseDialog {
       title: string,
       message: string,
       placeholder: string | undefined,
-      initialValue: string,
       validate?: (raw: string) => string | null,
     ) =>
     (
-      _currentValue: string,
+      currentValue: string,
       done: (selectedValue?: string) => void,
     ): Component => {
       const dialog = new InputDialog({
@@ -188,7 +191,7 @@ export class InputDialog extends BaseDialog {
         title,
         message,
         placeholder,
-        initialValue,
+        initialValue: currentValue,
         validate,
         onSubmit: (value) => done(value),
         onCancel: () => done(undefined),

package/src/ui/overrideSettingsList.ts

@@ -62,7 +62,34 @@ export interface OverrideSettingsListOptions {
  * `onChange` (both finite cycling and `done(value)` from the input
  * submenus arrive there), so no per-field callback is needed here.
  */
-const buildOverrideFieldItems = (
+/**
+ * Canonical display label for one of an override's editable fields —
+ * the single source of truth for both the field rows' `currentValue`
+ * and the post-commit refresh of an open field submenu, so the two
+ * can't drift.
+ */
+export const overrideFieldValue = (
+  field: string,
+  override: ModelOverride,
+): string => {
+  if (field.startsWith("cost.")) {
+    const costField = field.split(".")[1] as keyof ModelCostRates;
+    return String(override.cost?.[costField] ?? 0);
+  }
+  if (field === "capabilities")
+    return override.capabilities?.join(" | ") ?? "text";
+  if (field === "reasoning")
+    return override.reasoning === undefined
+      ? "true"
+      : override.reasoning
+        ? "true"
+        : "false";
+  if (field === "maxTokens") return String(override.maxTokens ?? 0);
+  if (field === "contextSize") return String(override.contextSize ?? 0);
+  return "";
+};
+
+export const buildOverrideFieldItems = (
   entry: { pattern: string; override: ModelOverride },
   theme: Theme,
   tui: TUI,
@@ -79,7 +106,6 @@ const buildOverrideFieldItems = (
       TITLES.edit(FIELDS.pattern.label),
       fieldMessage(FIELDS.pattern),
       FIELDS.pattern.placeholder,
-      entry.pattern,
       (raw) => {
         const trimmed = raw.trim();
         return trimmed.length > 0 ? trimmed : null;
@@ -91,14 +117,13 @@ const buildOverrideFieldItems = (
     id: "cost.input",
     label: FIELDS.inputCost.label,
     description: FIELDS.inputCost.description,
-    currentValue: String(entry.override.cost?.input ?? 0),
+    currentValue: overrideFieldValue("cost.input", entry.override),
     submenu: InputDialog.inputSubmenu(
       theme,
       tui,
       TITLES.edit(FIELDS.inputCost.label),
       fieldMessage(FIELDS.inputCost),
       FIELDS.inputCost.placeholder,
-      String(entry.override.cost?.input ?? 0),
       (raw) => {
         const parsed = parseCostValue(raw);
         return parsed === null ? null : String(parsed);
@@ -110,14 +135,13 @@ const buildOverrideFieldItems = (
     id: "cost.output",
     label: FIELDS.outputCost.label,
     description: FIELDS.outputCost.description,
-    currentValue: String(entry.override.cost?.output ?? 0),
+    currentValue: overrideFieldValue("cost.output", entry.override),
     submenu: InputDialog.inputSubmenu(
       theme,
       tui,
       TITLES.edit(FIELDS.outputCost.label),
       fieldMessage(FIELDS.outputCost),
       FIELDS.outputCost.placeholder,
-      String(entry.override.cost?.output ?? 0),
       (raw) => {
         const parsed = parseCostValue(raw);
         return parsed === null ? null : String(parsed);
@@ -129,14 +153,13 @@ const buildOverrideFieldItems = (
     id: "cost.cacheRead",
     label: FIELDS.cacheReadCost.label,
     description: FIELDS.cacheReadCost.description,
-    currentValue: String(entry.override.cost?.cacheRead ?? 0),
+    currentValue: overrideFieldValue("cost.cacheRead", entry.override),
     submenu: InputDialog.inputSubmenu(
       theme,
       tui,
       TITLES.edit(FIELDS.cacheReadCost.label),
       fieldMessage(FIELDS.cacheReadCost),
       FIELDS.cacheReadCost.placeholder,
-      String(entry.override.cost?.cacheRead ?? 0),
       (raw) => {
         const parsed = parseCostValue(raw);
         return parsed === null ? null : String(parsed);
@@ -148,14 +171,13 @@ const buildOverrideFieldItems = (
     id: "cost.cacheWrite",
     label: FIELDS.cacheWriteCost.label,
     description: FIELDS.cacheWriteCost.description,
-    currentValue: String(entry.override.cost?.cacheWrite ?? 0),
+    currentValue: overrideFieldValue("cost.cacheWrite", entry.override),
     submenu: InputDialog.inputSubmenu(
       theme,
       tui,
       TITLES.edit(FIELDS.cacheWriteCost.label),
       fieldMessage(FIELDS.cacheWriteCost),
       FIELDS.cacheWriteCost.placeholder,
-      String(entry.override.cost?.cacheWrite ?? 0),
       (raw) => {
         const parsed = parseCostValue(raw);
         return parsed === null ? null : String(parsed);
@@ -167,7 +189,7 @@ const buildOverrideFieldItems = (
     id: "capabilities",
     label: FIELDS.capabilities.label,
     description: FIELDS.capabilities.description,
-    currentValue: entry.override.capabilities?.join(" | ") ?? "text",
+    currentValue: overrideFieldValue("capabilities", entry.override),
     values: ["text", "text | image"],
   },
   // Reasoning — finite: true or false
@@ -175,12 +197,7 @@ const buildOverrideFieldItems = (
     id: "reasoning",
     label: FIELDS.reasoning.label,
     description: FIELDS.reasoning.description,
-    currentValue:
-      entry.override.reasoning === undefined
-        ? "true"
-        : entry.override.reasoning
-          ? "true"
-          : "false",
+    currentValue: overrideFieldValue("reasoning", entry.override),
     values: ["true", "false"],
   },
   // Context size — infinite
@@ -188,14 +205,13 @@ const buildOverrideFieldItems = (
     id: "contextSize",
     label: FIELDS.contextSize.label,
     description: FIELDS.contextSize.description,
-    currentValue: String(entry.override.contextSize ?? 0),
+    currentValue: overrideFieldValue("contextSize", entry.override),
     submenu: InputDialog.inputSubmenu(
       theme,
       tui,
       TITLES.edit(FIELDS.contextSize.label),
       fieldMessage(FIELDS.contextSize),
       FIELDS.contextSize.placeholder,
-      String(entry.override.contextSize ?? 0),
       (raw) => {
         const n = Number(raw.trim());
         return n >= 0 && isFinite(n) ? String(n) : null;
@@ -207,14 +223,13 @@ const buildOverrideFieldItems = (
     id: "maxTokens",
     label: FIELDS.maxTokens.label,
     description: FIELDS.maxTokens.description,
-    currentValue: String(entry.override.maxTokens ?? 0),
+    currentValue: overrideFieldValue("maxTokens", entry.override),
     submenu: InputDialog.inputSubmenu(
       theme,
       tui,
       TITLES.edit(FIELDS.maxTokens.label),
       fieldMessage(FIELDS.maxTokens),
       FIELDS.maxTokens.placeholder,
-      String(entry.override.maxTokens ?? 0),
       (raw) => {
         const n = Number(raw.trim());
         return n >= 0 && isFinite(n) ? String(n) : null;
@@ -256,6 +271,8 @@ class OverrideEntryListEditor implements Component, Focusable {
   private isFocused = false;
   private _selectedIndex = 0;
   private submenuOpen = false;
+  /** Currently open field submenu, so commits can refresh its rows */
+  private fieldList: SettingsList | null = null;
 
   constructor(
     /** Shared options object — `persistSnapshot` updates `options.servers`
@@ -389,8 +406,7 @@ class OverrideEntryListEditor implements Component, Focusable {
         // so `i` is stable for this list instance's lifetime)
         const current = this.getEntries()[i] ?? entry;
         const fieldItems = buildOverrideFieldItems(current, theme, tui);
-        this.submenuOpen = true;
-        return new SettingsList(
+        const fieldList = new SettingsList(
           fieldItems,
           Math.min(fieldItems.length + 2, 15),
           getSettingsListTheme(),
@@ -399,9 +415,15 @@ class OverrideEntryListEditor implements Component, Focusable {
           (field, value) => void this.handleFieldChange(i, field, value),
           () => {
             this.submenuOpen = false;
+            this.fieldList = null;
             done();
           },
         );
+        // Kept so handleFieldChange can refresh the open submenu's rows
+        // after a commit (the submenu stays open across edits)
+        this.fieldList = fieldList;
+        this.submenuOpen = true;
+        return fieldList;
       },
     }));
 
@@ -622,12 +644,18 @@ class OverrideEntryListEditor implements Component, Focusable {
       entry.pattern,
       updatedOverride,
     );
-    // Keep the field submenu open — just refresh the entry's summary row
+    // Keep the field submenu open — refresh the entry's summary row and
+    // the open submenu's own row so re-entering the field prefills the
+    // value just saved (InputDialog prefills from the row's currentValue)
     await this.persistSnapshot(next, () => {
       this.settingsList?.updateValue(
         `entry-${entryIndex}`,
         formatOverrideSummary(updatedOverride),
       );
+      this.fieldList?.updateValue(
+        field,
+        overrideFieldValue(field, updatedOverride),
+      );
       this.options.tui.requestRender();
     });
   }

package/src/ui/serverListEditor.ts

@@ -1,5 +1,7 @@
 import { PROVIDER_PREFIX } from "../constants";
+import { ServerStatus } from "../enums/serverStatus";
 import type { LlamaServer } from "../interfaces/settings";
+import { checkServerHealth } from "../utils/health";
 import { normalizeUrl } from "../utils/urls";
 
 /**
@@ -30,3 +32,28 @@ export const formatServerSuffix = (server: LlamaServer): string => {
   const id = server.id ?? `${PROVIDER_PREFIX}=${server.url}`;
   return server.name ? `(${id} - ${server.name})` : `(${server.id})`;
 };
+
+/**
+ * Emoji indicators for server health status.
+ */
+const SERVER_STATUS_ICONS: Record<ServerStatus, string> = {
+  [ServerStatus.READY]: "🟢",
+  [ServerStatus.TIMEOUT]: "🟡",
+  [ServerStatus.UNREACHABLE]: "🔴",
+};
+
+/**
+ * Checks the health of a server and returns the corresponding emoji.
+ *
+ * Delegates the probe/classification to the shared `checkServerHealth`
+ * (`utils/health`) — this wrapper only maps the status to its icon.
+ *
+ * @param url - The server URL to check
+ * @param timeout - Maximum time (ms) to wait for the health check
+ * @returns The health emoji for the server status
+ */
+export const getServerHealthEmoji = async (
+  url: string,
+  timeout: number,
+): Promise<string> =>
+  SERVER_STATUS_ICONS[await checkServerHealth(url, timeout)];

package/src/ui/serverSettingsList.ts

@@ -11,7 +11,11 @@ import type {
 import { SettingsList, type SettingItem } from "@earendil-works/pi-tui";
 import type { LlamaServer } from "../interfaces/settings";
 import { ConfirmDialog, InputDialog } from "./dialog";
-import { formatServerSuffix, normalizeServerUrl } from "./serverListEditor";
+import {
+  formatServerSuffix,
+  getServerHealthEmoji,
+  normalizeServerUrl,
+} from "./serverListEditor";
 import { fieldMessage, FIELDS, HINTS, TITLES } from "./strings";
 
 /**
@@ -36,6 +40,8 @@ export interface ServerSettingsListOptions {
   done: () => void;
   /** Notifies about persistence errors */
   onError: (message: string) => void;
+  /** Timeout (ms) for health checks. Defaults to 1000ms if not provided. */
+  serverTimeout?: number;
 }
 
 /**
@@ -59,7 +65,6 @@ const buildServerFieldItems = (
       TITLES.edit(FIELDS.serverUrl.label),
       fieldMessage(FIELDS.serverUrl),
       FIELDS.serverUrl.placeholder,
-      server.url,
       normalizeServerUrl,
     ),
   },
@@ -74,7 +79,6 @@ const buildServerFieldItems = (
       TITLES.edit(FIELDS.providerId.label),
       fieldMessage(FIELDS.providerId),
       FIELDS.providerId.placeholder,
-      server.id ?? "",
     ),
   },
   {
@@ -88,7 +92,6 @@ const buildServerFieldItems = (
       TITLES.edit(FIELDS.displayName.label),
       fieldMessage(FIELDS.displayName),
       FIELDS.displayName.placeholder,
-      server.name ?? "",
     ),
   },
 ];
@@ -103,21 +106,27 @@ const buildServerRow = (
   theme: Theme,
   tui: TUI,
   onChange: (field: string, value: string) => void,
+  healthEmoji: string,
+  onSubmenuChange: (open: boolean) => void,
 ): SettingItem => ({
   id: `server-${index}`,
-  label: server.url,
+  label: `${healthEmoji} ${server.url}`,
   description: HINTS.serverRow,
   currentValue: formatServerSuffix(server),
   submenu: (_cv, done) => {
     // Rebuild the field items on open so they prefill with current values
     const items = buildServerFieldItems(server, theme, tui);
+    onSubmenuChange(true);
     return new SettingsList(
       items,
       Math.min(items.length + 2, 15),
       getSettingsListTheme(),
       // Field commits arrive here: done(value) from the input submenus
       (field, value) => onChange(field, value),
-      done,
+      () => {
+        onSubmenuChange(false);
+        done();
+      },
     );
   },
 });
@@ -135,7 +144,7 @@ const buildServerRow = (
  * - **Esc** closes the editor.
  */
 export class ServerSettingsList implements Component, Focusable {
-  private settingsList: SettingsList;
+  private settingsList!: SettingsList;
   private mode: "list" | "wizard" | "confirm" = "list";
   private wizardStep = 0;
   private wizardUrl = "";
@@ -143,9 +152,14 @@ export class ServerSettingsList implements Component, Focusable {
   private wizardDialog: InputDialog | undefined;
   private confirmDialog: ConfirmDialog | undefined;
   private isFocused = false;
+  /** True while a server row's field-edit submenu is open */
+  private submenuOpen = false;
 
   constructor(private readonly options: ServerSettingsListOptions) {
-    this.settingsList = this.buildSettingsList();
+    this.buildSettingsList().then((list) => {
+      this.settingsList = list;
+      this.options.tui.requestRender();
+    });
   }
 
   /**
@@ -154,11 +168,30 @@ export class ServerSettingsList implements Component, Focusable {
    * successful persist so added/deleted/edited servers are reflected
    * immediately (the initial snapshot is not mutated by `persist`).
    */
-  private buildSettingsList(): SettingsList {
+  private async buildSettingsList(): Promise<SettingsList> {
     const { theme, tui } = this.options;
+    const serverTimeout = this.options.serverTimeout ?? 1000;
+    // Check health for each server in parallel
+    const healthEmojis = await Promise.all(
+      this.options.servers.map((server) =>
+        getServerHealthEmoji(server.url, serverTimeout),
+      ),
+    );
+
+    // A fresh list never has a submenu open (also covers the rebuild
+    // paths, which discard any open field submenu)
+    this.submenuOpen = false;
     const items: SettingItem[] = this.options.servers.map((server, i) =>
-      buildServerRow(server, i, theme, tui, (field, value) =>
-        this.handleFieldChange(field, value),
+      buildServerRow(
+        server,
+        i,
+        theme,
+        tui,
+        (field, value) => this.handleFieldChange(field, value),
+        healthEmojis[i],
+        (open) => {
+          this.submenuOpen = open;
+        },
       ),
     );
 
@@ -190,7 +223,7 @@ export class ServerSettingsList implements Component, Focusable {
   // -- Component -----------------------------------------------------------
 
   invalidate(): void {
-    this.settingsList.invalidate();
+    this.settingsList?.invalidate();
     this.wizardDialog?.invalidate();
     this.confirmDialog?.invalidate();
   }
@@ -206,6 +239,15 @@ export class ServerSettingsList implements Component, Focusable {
       return;
     }
 
+    // A server row's field submenu is open: delegate everything (Esc,
+    // a/d, arrows) to the containing SettingsList, which forwards input
+    // to the submenu. Intercepting here would close the whole editor on
+    // Esc and trigger add/delete while typing in a field.
+    if (this.submenuOpen) {
+      this.settingsList?.handleInput(data);
+      return;
+    }
+
     const kb = this.options.keybindings;
     if (kb.matches(data, "tui.select.cancel")) {
       this.options.done();
@@ -233,7 +275,7 @@ export class ServerSettingsList implements Component, Focusable {
       return;
     }
     // Delegate to SettingsList (it handles up/down internally for rendering)
-    this.settingsList.handleInput(data);
+    this.settingsList?.handleInput(data);
   }
 
   render(width: number): string[] {
@@ -245,6 +287,10 @@ export class ServerSettingsList implements Component, Focusable {
       return this.confirmDialog?.render(width) ?? [];
     }
 
+    // settingsList may not be initialized yet if buildSettingsList is still
+    // resolving health checks (async in constructor). Return empty until ready.
+    if (!this.settingsList) return [];
+
     // List mode: the shortcuts live in the rows' description; only when the
     // list is empty (no rows → no description) show them as the hint line
     const settingsLines = this.settingsList.render(width);
@@ -272,8 +318,9 @@ export class ServerSettingsList implements Component, Focusable {
    * (clamped to the last row). A fresh SettingsList starts its cursor
    * at index 0, so `selectItem` is used to restore the position.
    */
-  private rebuildList(targetIndex: number): void {
-    this.settingsList = this.buildSettingsList();
+  private async rebuildList(targetIndex: number): Promise<void> {
+    const list = await this.buildSettingsList();
+    this.settingsList = list;
     const count = this.options.servers.length;
     if (count === 0) {
       this._selectedIndex = 0;
@@ -381,7 +428,7 @@ export class ServerSettingsList implements Component, Focusable {
       // Adopt the persisted list and rebuild so the new row appears;
       // the new server is appended last — put the cursor on it
       this.options.servers = next;
-      this.rebuildList(next.length - 1);
+      await this.rebuildList(next.length - 1);
       this.mode = "list";
     } catch (err) {
       this.options.onError(String(err));
@@ -426,7 +473,7 @@ export class ServerSettingsList implements Component, Focusable {
       // the server that followed the deleted one now sits at the same
       // index (rebuildList clamps when the last row was deleted)
       this.options.servers = next;
-      this.rebuildList(idx);
+      await this.rebuildList(idx);
       this.mode = "list";
     } catch (err) {
       this.options.onError(String(err));
@@ -456,7 +503,7 @@ export class ServerSettingsList implements Component, Focusable {
       // URL/id/name changes alter row labels → rebuild the list;
       // keep the cursor on the edited server
       this.options.servers = next;
-      this.rebuildList(idx);
+      await this.rebuildList(idx);
       this.options.tui.requestRender();
     } catch (err) {
       this.options.onError(String(err));

package/src/utils/health.ts

@@ -0,0 +1,48 @@
+import { ServerStatus } from "../enums/serverStatus";
+
+/**
+ * Probes a llama-server's `/health` endpoint and classifies the outcome.
+ *
+ * The single source of truth for health classification — both
+ * `Server.isReady` and the UI health indicators delegate here.
+ *
+ * - HTTP success with `{ status: "ok" }`  → `READY`
+ * - The request is still in flight when the deadline passes
+ *   (`AbortSignal.timeout` aborts it)     → `TIMEOUT`
+ * - Anything else (network error, non-JSON or non-ok payload)
+ *                                         → `UNREACHABLE`
+ *
+ * The HTTP status code itself is not inspected: a llama-server answers
+ * `/health` with the payload's `status` field, and both classification
+ * branches key off it (matching the behavior of `ApiClient.get`, which
+ * also ignores status codes and parses the body).
+ *
+ * @param url The bare origin of the llama-server (the endpoint is
+ *   `<url>/health`, without the `/v1` prefix)
+ * @param timeout Maximum time (ms) to wait for the health check
+ * @param apiKey Optional API key, sent as a Bearer token — servers
+ *   behind an API-key gate would otherwise report UNREACHABLE
+ * @returns The classified server status
+ */
+export const checkServerHealth = async (
+  url: string,
+  timeout: number,
+  apiKey?: string,
+): Promise<ServerStatus> => {
+  try {
+    const response = await fetch(`${url}/health`, {
+      signal: AbortSignal.timeout(timeout),
+      headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined,
+    });
+    const data = (await response.json()) as { status?: string };
+    return data.status === "ok" ? ServerStatus.READY : ServerStatus.UNREACHABLE;
+  } catch (error) {
+    // `AbortSignal.timeout` rejects `fetch` with a `TimeoutError`
+    // DOMException (some runtimes surface it as `AbortError` with a
+    // timeout message).
+    const isTimeout =
+      error instanceof Error &&
+      (error.name === "TimeoutError" || error.name === "AbortError");
+    return isTimeout ? ServerStatus.TIMEOUT : ServerStatus.UNREACHABLE;
+  }
+};

package/tests/commandManager.test.ts

@@ -11,6 +11,7 @@ import {
 } from "../src/managers/command";
 import { ServerManager } from "../src/managers/server";
 import type { LlamaSettingsManager } from "../src/managers/settings";
+import * as serverListEditor from "../src/ui/serverListEditor";
 import { ServerSettingsList } from "../src/ui/serverSettingsList";
 import {
   createMockCtx,
@@ -25,8 +26,27 @@ beforeEach(() => {
   initTheme();
   vi.clearAllMocks();
   mockRpc.mockResolvedValue({ data: [] });
+  // Mock health checks to return "healthy" immediately
+  vi.spyOn(serverListEditor, "getServerHealthEmoji").mockResolvedValue("🟢");
 });
 
+/**
+ * Waits for a ServerSettingsList to finish its async initialization
+ * (health checks + SettingsList construction).
+ */
+const waitForEditor = (editor: ServerSettingsList): Promise<void> =>
+  new Promise((resolve) => {
+    const check = () => {
+      // @ts-expect-error settingsList is private
+      if (editor.settingsList) {
+        resolve();
+      } else {
+        setTimeout(check, 10);
+      }
+    };
+    check();
+  });
+
 describe("CommandManager", () => {
   let serverManager: ServerManager;
   let commandManager: CommandManager;
@@ -289,6 +309,8 @@ describe("CommandManager", () => {
       );
 
       expect(editor).toBeInstanceOf(ServerSettingsList);
+      // Wait for async health checks to complete
+      await waitForEditor(editor);
       // Seeded with the merged snapshot
       expect(editor.render(80).join("\n")).toContain("http://seed:1");
 
@@ -302,6 +324,7 @@ describe("CommandManager", () => {
       editor.handleInput(ENTER); // skip optional ID
       expect(editor.render(80).join("\n")).toContain("Add server · 3/3");
       editor.handleInput(ENTER); // skip optional name → persist
+      // Wait for async persist and rebuild
       await new Promise((resolve) => setTimeout(resolve, 0));
       expect(editorSettings.setLlamaSetting).toHaveBeenCalledWith("servers", [
         { url: "http://seed:1" },
@@ -372,6 +395,9 @@ describe("CommandManager", () => {
         vi.fn(),
       );
 
+      // Wait for async health checks to complete
+      await waitForEditor(editor);
+
       // Move to the second row and open the confirm dialog
       editor.handleInput("\x1b[B");
       editor.handleInput("d");

package/tests/dialog.test.ts

@@ -6,6 +6,7 @@ import {
 } from "@earendil-works/pi-tui";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import { ConfirmDialog, InputDialog } from "../src/ui/dialog";
+import { createOverrideSettingsList } from "../src/ui/overrideSettingsList";
 import { ServerSettingsList } from "../src/ui/serverSettingsList";
 
 beforeEach(() => {
@@ -184,3 +185,44 @@ describe("ServerSettingsList add wizard", () => {
     expect(editor.render(80).join("\n")).toContain("(a) add server");
   });
 });
+
+describe("OverrideEntryListEditor cost re-prefill", () => {
+  const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+  it("re-entering a cost field prefills the just-saved value", async () => {
+    const persist = vi.fn().mockResolvedValue(undefined);
+    const list = createOverrideSettingsList({
+      tui: createMockTui(),
+      theme: createMockTheme(),
+      keybindings: createKeybindings(),
+      servers: [
+        {
+          url: "http://x:1",
+          overrides: { "gpt-*": { cost: { input: 0.2 } } },
+        },
+      ] as never[],
+      persist,
+      done: vi.fn(),
+      onError: vi.fn(),
+      onChanged: vi.fn(),
+    });
+
+    const DOWN = "\x1b[B"; // tui.select.down
+    const CLEAR = "\x15"; // tui.editor.deleteToLineStart
+
+    list.handleInput(ENTER); // drill into the server row
+    list.handleInput(ENTER); // open the field submenu (cursor: pattern)
+    list.handleInput(DOWN); // cursor: cost.input
+    list.handleInput(ENTER); // open the input dialog (prefilled "0.2")
+    list.handleInput(CLEAR);
+    for (const ch of "0.5") list.handleInput(ch);
+    list.handleInput(ENTER); // commit
+    await flush();
+
+    // Re-enter the field: the prefill must be the saved value
+    list.handleInput(ENTER);
+    const rendered = list.render(80).join("\n");
+    expect(rendered).toContain("0.5");
+    expect(rendered).not.toContain("0.2");
+  });
+});

package/tests/health.test.ts

@@ -0,0 +1,116 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { ServerStatus } from "../src/enums/serverStatus";
+import { checkServerHealth } from "../src/utils/health";
+
+/**
+ * Stubs `global.fetch` for one test. The probe only reads the parsed body,
+ * so a fake response is just a `json()` accessor.
+ */
+const stubFetch = (
+  impl: (url: string, init?: RequestInit) => Promise<unknown>,
+) => vi.stubGlobal("fetch", vi.fn(impl));
+
+const okResponse = () => ({ json: async () => ({ status: "ok" }) });
+
+const URL_ = "http://127.0.0.1:8080";
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+describe("checkServerHealth", () => {
+  it("should return READY when the payload status is ok", async () => {
+    stubFetch(async () => ({ json: async () => ({ status: "ok" }) }));
+
+    expect(await checkServerHealth(URL_, 1000)).toBe(ServerStatus.READY);
+  });
+
+  it("should return UNREACHABLE when the payload status is not ok", async () => {
+    stubFetch(async () => ({ json: async () => ({ status: "error" }) }));
+
+    expect(await checkServerHealth(URL_, 1000)).toBe(ServerStatus.UNREACHABLE);
+  });
+
+  it("should return UNREACHABLE when the payload has no status field", async () => {
+    // llama-server answers a loading model with a 503 + error payload
+    stubFetch(async () => ({
+      json: async () => ({ error: { message: "Loading model" } }),
+    }));
+
+    expect(await checkServerHealth(URL_, 1000)).toBe(ServerStatus.UNREACHABLE);
+  });
+
+  it("should return UNREACHABLE when the body is not JSON", async () => {
+    stubFetch(async () => ({
+      json: async () => {
+        throw new Error("Unexpected token");
+      },
+    }));
+
+    expect(await checkServerHealth(URL_, 1000)).toBe(ServerStatus.UNREACHABLE);
+  });
+
+  it("should return UNREACHABLE on a network error", async () => {
+    stubFetch(async () => {
+      throw new Error("connection refused");
+    });
+
+    expect(await checkServerHealth(URL_, 1000)).toBe(ServerStatus.UNREACHABLE);
+  });
+
+  it("should return TIMEOUT when the fetch aborts with TimeoutError", async () => {
+    stubFetch(async () => {
+      throw new DOMException("The operation timed out.", "TimeoutError");
+    });
+
+    expect(await checkServerHealth(URL_, 1000)).toBe(ServerStatus.TIMEOUT);
+  });
+
+  it("should return TIMEOUT when the fetch aborts with AbortError", async () => {
+    // Some runtimes surface the timeout as a plain AbortError
+    stubFetch(async () => {
+      throw new DOMException("The user aborted a request.", "AbortError");
+    });
+
+    expect(await checkServerHealth(URL_, 1000)).toBe(ServerStatus.TIMEOUT);
+  });
+
+  it("should hit <url>/health", async () => {
+    const fetchMock = vi.fn(async (_url: string, _init?: RequestInit) =>
+      okResponse(),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+
+    await checkServerHealth(URL_, 1000);
+
+    expect(fetchMock).toHaveBeenCalledWith(`${URL_}/health`, {
+      signal: expect.any(AbortSignal),
+      headers: undefined,
+    });
+  });
+
+  it("should send the API key as a Bearer token when provided", async () => {
+    const fetchMock = vi.fn(async (_url: string, _init?: RequestInit) =>
+      okResponse(),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+
+    await checkServerHealth(URL_, 1000, "secret-key");
+
+    expect(fetchMock).toHaveBeenCalledWith(`${URL_}/health`, {
+      signal: expect.any(AbortSignal),
+      headers: { Authorization: "Bearer secret-key" },
+    });
+  });
+
+  it("should omit the Authorization header when no key is given", async () => {
+    const fetchMock = vi.fn(async (_url: string, _init?: RequestInit) =>
+      okResponse(),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+
+    await checkServerHealth(URL_, 1000);
+
+    expect(fetchMock.mock.calls[0]?.[1]?.headers).toBeUndefined();
+  });
+});

package/tests/overrides.test.ts

@@ -11,6 +11,7 @@ import {
   removeOverrideEntry,
   updateOverrideEntry,
 } from "../src/ui/overrideEntryEditor";
+import { overrideFieldValue } from "../src/ui/overrideSettingsList";
 import { createMockServer, mockRpc } from "./mocks";
 
 beforeEach(() => {
@@ -350,3 +351,34 @@ describe("override entry list helpers", () => {
     });
   });
 });
+
+describe("overrideFieldValue", () => {
+  it("formats cost fields, defaulting to 0", () => {
+    expect(overrideFieldValue("cost.input", {})).toBe("0");
+    expect(overrideFieldValue("cost.input", { cost: { input: 0.2 } })).toBe(
+      "0.2",
+    );
+    expect(overrideFieldValue("cost.cacheWrite", {})).toBe("0");
+  });
+
+  it("formats capabilities and reasoning labels", () => {
+    expect(overrideFieldValue("capabilities", {})).toBe("text");
+    expect(
+      overrideFieldValue("capabilities", { capabilities: ["text", "image"] }),
+    ).toBe("text | image");
+    expect(overrideFieldValue("reasoning", {})).toBe("true");
+    expect(overrideFieldValue("reasoning", { reasoning: false })).toBe("false");
+  });
+
+  it("formats maxTokens/contextSize, defaulting to 0", () => {
+    expect(overrideFieldValue("maxTokens", {})).toBe("0");
+    expect(overrideFieldValue("maxTokens", { maxTokens: 4096 })).toBe("4096");
+    expect(overrideFieldValue("contextSize", { contextSize: 8192 })).toBe(
+      "8192",
+    );
+  });
+
+  it("returns an empty label for unknown fields", () => {
+    expect(overrideFieldValue("other", {})).toBe("");
+  });
+});

package/tests/server.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { POLLING_TIMEOUT, SERVER_TIMEOUT } from "../src/constants";
 import { ServerStatus } from "../src/enums/serverStatus";
 import type { LlamaSettingsManager } from "../src/managers/settings";
@@ -35,6 +35,26 @@ describe("Server providerName", () => {
   });
 });
 
+describe("Server apiBaseUrl", () => {
+  it("should append the ENDPOINT_PREFIX to baseUrl", () => {
+    const server = new Server(settings, { baseUrl: "http://127.0.0.1:8080" });
+    expect(server.apiBaseUrl).toBe("http://127.0.0.1:8080/v1");
+  });
+
+  it("should not double the prefix when baseUrl already ends with it", () => {
+    const server = new Server(settings, {
+      baseUrl: "http://127.0.0.1:8080/v1",
+    });
+    expect(server.apiBaseUrl).toBe("http://127.0.0.1:8080/v1");
+  });
+
+  it("should keep baseUrl untouched for provider identity", () => {
+    const server = new Server(settings, { baseUrl: "http://127.0.0.1:8080" });
+    expect(server.baseUrl).toBe("http://127.0.0.1:8080");
+    expect(server.providerId).toBe("llama-server=http://127.0.0.1:8080");
+  });
+});
+
 describe("Server fetchModels", () => {
   it("should call the /models endpoint", async () => {
     mockRpc.mockResolvedValueOnce({
@@ -195,8 +215,18 @@ describe("Server timeouts", async () => {
 });
 
 describe("Server isReady", () => {
+  // `isReady` delegates to the shared health probe (`utils/health`), which
+  // uses plain `fetch` instead of the ApiClient — stub it per test.
+  const stubFetch = (impl: () => Promise<unknown>) => {
+    vi.stubGlobal("fetch", vi.fn(impl));
+  };
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
   it("should return READY when health status is ok", async () => {
-    mockRpc.mockResolvedValueOnce({ status: "ok" });
+    stubFetch(async () => ({ json: async () => ({ status: "ok" }) }));
 
     const server = createMockServer();
     const status = await server.isReady(1000);
@@ -205,7 +235,9 @@ describe("Server isReady", () => {
   });
 
   it("should return UNREACHABLE when health check fails", async () => {
-    mockRpc.mockRejectedValueOnce(new Error("connection refused"));
+    stubFetch(async () => {
+      throw new Error("connection refused");
+    });
 
     const server = createMockServer();
     const status = await server.isReady(1000);
@@ -214,11 +246,22 @@ describe("Server isReady", () => {
   });
 
   it("should return UNREACHABLE when health status is not ok", async () => {
-    mockRpc.mockResolvedValueOnce({ status: "error" });
+    stubFetch(async () => ({ json: async () => ({ status: "error" }) }));
 
     const server = createMockServer();
     const status = await server.isReady(1000);
 
     expect(status).toBe(ServerStatus.UNREACHABLE);
   });
+
+  it("should return TIMEOUT when the health check aborts", async () => {
+    stubFetch(async () => {
+      throw new DOMException("The operation timed out.", "TimeoutError");
+    });
+
+    const server = createMockServer();
+    const status = await server.isReady(1000);
+
+    expect(status).toBe(ServerStatus.TIMEOUT);
+  });
 });

package/tests/serverManager.test.ts

@@ -69,7 +69,7 @@ describe("ServerManager", () => {
       "llama-server=http://127.0.0.1:8080",
       {
         name: "Llama.cpp (http://127.0.0.1:8080)",
-        baseUrl: "http://127.0.0.1:8080",
+        baseUrl: "http://127.0.0.1:8080/v1",
         api: "openai-completions",
         apiKey: "key-1",
         models: [{ id: "test-model" }],
@@ -79,7 +79,7 @@ describe("ServerManager", () => {
       "llama-server=http://127.0.0.1:8081",
       {
         name: "Llama.cpp (http://127.0.0.1:8081)",
-        baseUrl: "http://127.0.0.1:8081",
+        baseUrl: "http://127.0.0.1:8081/v1",
         api: "openai-completions",
         apiKey: "key-2",
         models: [{ id: "test-model" }],
@@ -133,7 +133,7 @@ describe("ServerManager", () => {
 
       expect(mockPi.registerProvider).toHaveBeenCalledWith(
         "llama-server=http://127.0.0.1:8081",
-        expect.objectContaining({ baseUrl: "http://127.0.0.1:8081" }),
+        expect.objectContaining({ baseUrl: "http://127.0.0.1:8081/v1" }),
       );
       expect(manager.servers).toHaveLength(2);
       const models = await manager.getAllModels();
@@ -184,7 +184,7 @@ describe("ServerManager", () => {
       );
       expect(mockPi.registerProvider).toHaveBeenCalledWith(
         "llama-server=http://127.0.0.1:9090",
-        expect.objectContaining({ baseUrl: "http://127.0.0.1:9090" }),
+        expect.objectContaining({ baseUrl: "http://127.0.0.1:9090/v1" }),
       );
       expect(manager.servers[0]?.providerId).toBe(
         "llama-server=http://127.0.0.1:9090",