pi-llama-cpp 0.14.0 → 0.15.0

package/src/ui/editors/override/entryEditor.ts

@@ -1,11 +1,11 @@
 import type { SettingItem, SettingsList } from "@earendil-works/pi-tui";
+import type { LlamaServer, ModelOverride } from "../../../interfaces/settings";
 import { FIELDS, FieldMessages, HINTS, TITLES } from "../../strings";
 import type { OverrideSettingsListOptions } from "../editorOptions";
 import { ListEditor } from "../listEditor";
 import { SettingsListFactory } from "../settingsListFactory";
 import { OverrideEntry } from "./entry";
-import { OverrideFields, OverrideSummary } from "./fields";
-import { OverrideEntryMutator } from "./handlers";
+import { OverrideFields, OverrideSummary } from "./fields/index";
 import { OverrideItemBuilder } from "./itemBuilder";
 
 /**
@@ -39,13 +39,13 @@ export class OverrideEntryListEditor extends ListEditor<OverrideSettingsListOpti
 
   protected buildSettingsList(): SettingsList {
     const builder = new OverrideItemBuilder(this.dialogs);
-    const items: SettingItem[] = this.mutator.entries().map((entry, i) => ({
+    const items: SettingItem[] = this.entries().map((entry, i) => ({
       id: `entry-${i}`,
       label: entry.pattern,
       description: HINTS.overrideEntryRow,
       currentValue: OverrideSummary.of(entry.override),
       submenu: (_cv, done) => {
-        const current = this.mutator.entries()[i] ?? entry;
+        const current = this.entries()[i] ?? entry;
         const fieldItems = builder.buildFieldItems(current);
         const fieldList = SettingsListFactory.create(
           fieldItems,
@@ -75,7 +75,7 @@ export class OverrideEntryListEditor extends ListEditor<OverrideSettingsListOpti
     field: string,
     value: string,
   ): void {
-    const result = this.mutator.applyFieldChange(entryIndex, field, value);
+    const result = this.applyFieldChange(entryIndex, field, value);
     if (!result) return;
 
     this.commitFieldChange(
@@ -121,7 +121,7 @@ export class OverrideEntryListEditor extends ListEditor<OverrideSettingsListOpti
 
   protected deleteSelected(): void {
     const idx = this.selectedIndex;
-    const next = this.mutator.removeEntry(idx);
+    const next = this.removeEntry(idx);
     void this.persistSnapshot(next, () => {
       this.rebuildList(idx);
       this.options.onChanged?.();
@@ -131,8 +131,8 @@ export class OverrideEntryListEditor extends ListEditor<OverrideSettingsListOpti
 
   protected readonly emptyHintKey = "emptyOverrideEntries" as const;
 
-  protected getCurrentCount(): number {
-    return this.mutator.entries().length;
+  protected getCount(): number {
+    return this.entries().length;
   }
 
   protected getRowId(index: number): string {
@@ -140,7 +140,7 @@ export class OverrideEntryListEditor extends ListEditor<OverrideSettingsListOpti
   }
 
   protected getRowLabel(index: number): string {
-    return this.mutator.entries()[index]?.pattern ?? "";
+    return this.entries()[index]?.pattern ?? "";
   }
 
   protected get deleteTitle(): string {
@@ -149,16 +149,98 @@ export class OverrideEntryListEditor extends ListEditor<OverrideSettingsListOpti
 
   // -- helpers ---------------------------------------------------------------
 
-  /** Fresh mutator over the current servers snapshot — `persistSnapshot`
-   * replaces `options.servers` in place, so instances can't be cached. */
-  private get mutator(): OverrideEntryMutator {
-    return new OverrideEntryMutator(this.options.servers, this.serverIndex);
+  /** The server's override entries, in map iteration order. */
+  private entries(): OverrideEntry[] {
+    return OverrideEntry.listFrom(this.options.servers[this.serverIndex]);
+  }
+
+  /** Handles a field commit from an override entry's submenu. Returns
+   * `null` when the entry doesn't exist (stale index — no-op). */
+  private applyFieldChange(
+    entryIndex: number,
+    field: string,
+    value: string,
+  ): { next: LlamaServer[]; updatedOverride: ModelOverride } | null {
+    const entry = this.entries()[entryIndex];
+    if (!entry) return null;
+
+    // Pattern field: rename the pattern key, keep the override object
+    if (field === "pattern") {
+      return {
+        next: this.updateEntry(entryIndex, value, entry.override),
+        updatedOverride: entry.override,
+      };
+    }
+
+    // Other fields: let the field definition apply itself
+    const updatedOverride: ModelOverride = { ...entry.override };
+    OverrideFields.byId(field).apply(updatedOverride, value);
+
+    return {
+      next: this.updateEntry(entryIndex, entry.pattern, updatedOverride),
+      updatedOverride,
+    };
+  }
+
+  /** Adds a new override entry with a uniquified pattern. */
+  private addEntry(pattern: string): LlamaServer[] {
+    const server = this.options.servers[this.serverIndex];
+    if (!server) return this.options.servers;
+
+    const existing = new Set(Object.keys(server.overrides ?? {}));
+    let uniquePattern = pattern;
+    let n = 2;
+    while (existing.has(uniquePattern)) {
+      uniquePattern = `${pattern}-${n++}`;
+    }
+
+    return this.withServer((s) => ({
+      ...s,
+      overrides: { ...s.overrides, [uniquePattern]: {} },
+    }));
+  }
+
+  /** Removes the entry at `entryIndex`. */
+  private removeEntry(entryIndex: number): LlamaServer[] {
+    return this.withServer((s) => ({
+      ...s,
+      overrides: Object.fromEntries(
+        Object.entries(s.overrides ?? {}).filter((_, j) => j !== entryIndex),
+      ),
+    }));
+  }
+
+  /** Returns the servers with the target server replaced by
+   * `fn(server)`. Immutable. */
+  private withServer(fn: (server: LlamaServer) => LlamaServer): LlamaServer[] {
+    return this.options.servers.map((server, i) =>
+      i === this.serverIndex ? fn(server) : server,
+    );
+  }
+
+  /** Replaces the entry at `entryIndex` with `pattern → override` in a
+   * single mutation — used both for renaming the pattern and for editing
+   * its fields. The entry keeps its position in the map's iteration
+   * order. Immutable. */
+  private updateEntry(
+    entryIndex: number,
+    pattern: string,
+    override: ModelOverride,
+  ): LlamaServer[] {
+    return this.withServer((s) => ({
+      ...s,
+      overrides: Object.fromEntries(
+        Object.entries(s.overrides ?? {}).map(([k, v], j) =>
+          j === entryIndex ? [pattern, override] : [k, v],
+        ),
+      ),
+    }));
   }
 
   private async saveAdd(pattern: string): Promise<void> {
-    const next = this.mutator.addEntry(pattern);
+    const next = this.addEntry(pattern);
     await this.persistSnapshot(next, () => {
-      this.rebuildList(this.mutator.entries().length - 1);
+      this.rebuildList(this.entries().length - 1);
       this.options.onChanged?.();
       this.options.tui.requestRender();
     });

package/src/ui/editors/override/fields/base.ts

@@ -0,0 +1,53 @@
+import type { ModelOverride } from "../../../../interfaces/settings";
+import { SettingField } from "../../settingField";
+import { OverrideEntry } from "../entry";
+
+/** Type of a field: "input" for free-text, "finite" for fixed options */
+export type FieldType = "input" | "finite";
+
+/** Validation function for input fields */
+export type InputValidator = (raw: string) => string | null;
+
+/**
+ * Abstract base class for one editable field of a model override entry
+ * (Template Method): each subclass owns its display format, validation
+ * and apply logic in a single place, so the parse/format round-trips
+ * can't drift. Extends the shared {@link SettingField} base (id, label,
+ * description, placeholder from the FIELDS registry).
+ */
+export abstract class OverrideField extends SettingField<OverrideEntry> {
+  /** Field type: "input" for free-text, "finite" for fixed options. */
+  abstract readonly type: FieldType;
+
+  /**
+   * Canonical display label for this field — 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.
+   */
+  abstract displayValue(entry: OverrideEntry): string;
+
+  /** Current value shown in the row — defaults to `displayValue`. */
+  currentValue(entry: OverrideEntry): string {
+    return this.displayValue(entry);
+  }
+
+  /** For "input" fields: validation function for committed values. */
+  abstract readonly validate: InputValidator;
+
+  /** For "finite" fields: the fixed options (undefined for "input"). */
+  readonly options: readonly string[] | undefined = undefined;
+
+  /** Applies a committed value to the override object. The pattern key
+   * rename is handled separately by the mutator (default: no-op). */
+  apply(_override: ModelOverride, _value: string): void {
+    // no-op — override in subclasses that need to mutate the override
+  }
+
+  /** One `term: value` part of the entry-row summary (see
+   * {@link OverrideSummary.of}), or `null` when the field shouldn't
+   * appear (unset/zero values — each field decides). The pattern is the
+   * row label, so it never contributes a part; the default is `null`. */
+  summaryPart(_override: ModelOverride): string | null {
+    return null;
+  }
+}

package/src/ui/editors/override/fields/capabilities.ts

@@ -0,0 +1,36 @@
+import type { ModelOverride } from "../../../../interfaces/settings";
+import { FIELDS } from "../../../strings";
+import { OverrideEntry } from "../entry";
+import type { InputValidator } from "./base";
+import { OverrideField } from "./base";
+
+/** The override's `capabilities` list (finite: fixed label options). */
+export class CapabilitiesField extends OverrideField {
+  readonly id = "capabilities";
+  readonly type = "finite";
+  readonly field = FIELDS.capabilities;
+  override readonly options = ["text", "text | image"];
+
+  displayValue(entry: OverrideEntry): string {
+    return entry.override.capabilities?.join(" | ") ?? "text";
+  }
+
+  readonly validate: InputValidator = (raw) =>
+    this.options?.includes(raw) ? raw : null;
+
+  apply(override: ModelOverride, value: string): void {
+    override.capabilities =
+      value === "text | image"
+        ? ["text", "image"]
+        : value === "text"
+          ? ["text"]
+          : undefined;
+  }
+
+  /** Appears in the summary only when non-empty. */
+  override summaryPart(override: ModelOverride): string | null {
+    return override.capabilities?.length
+      ? `capabilities: ${override.capabilities.join(",")}`
+      : null;
+  }
+}

package/src/ui/editors/override/fields/cost.ts

@@ -0,0 +1,64 @@
+import type { ModelCost, ModelCostRates } from "@earendil-works/pi-ai";
+import type { ModelOverride } from "../../../../interfaces/settings";
+import type { Field } from "../../../strings";
+import { OverrideEntry } from "../entry";
+import type { InputValidator } from "./base";
+import { OverrideField } from "./base";
+import { parseNonNegative } from "./numeric";
+
+/**
+ * One `ModelCostRates` key of the override's `cost` object (absorbs the
+ * former `CostFieldDefFactory` and the standalone `parseCostValue` /
+ * `applyCostFieldValue` helpers): owns the cost parse and immutable
+ * apply in the same place as its display format.
+ */
+export class CostField extends OverrideField {
+  readonly type = "input";
+  override readonly field: Field;
+
+  constructor(
+    readonly id: string,
+    private readonly key: keyof ModelCostRates,
+    field: Field,
+    /** Short term used in the entry-row summary (e.g. `cache read`). */
+    private readonly summaryTerm: string,
+  ) {
+    super();
+    this.field = field;
+  }
+
+  displayValue(entry: OverrideEntry): string {
+    return String(entry.override.cost?.[this.key] ?? 0);
+  }
+
+  readonly validate: InputValidator = (raw) => {
+    const parsed = parseNonNegative(raw);
+    return parsed === null ? null : String(parsed);
+  };
+
+  apply(override: ModelOverride, value: string): void {
+    const nextCost = this.applyCost(override.cost, Number(value));
+    if (nextCost) override.cost = nextCost;
+    else delete override.cost;
+  }
+
+  /** Returns a copy of `cost` with this field set to `value`. A `0` (or
+   * non-finite) value removes the field — unset cost fields default to
+   * zero at read time — and when no fields remain, returns `undefined`
+   * so the whole `cost` object can be dropped. Immutable. */
+  private applyCost(
+    cost: ModelOverride["cost"],
+    value: number,
+  ): Partial<ModelCost> | undefined {
+    const next = { ...cost };
+    if (isFinite(value) && value > 0) next[this.key] = value;
+    else delete next[this.key];
+    return Object.keys(next).length > 0 ? next : undefined;
+  }
+
+  /** Appears in the summary only when a non-zero cost is set. */
+  override summaryPart(override: ModelOverride): string | null {
+    const value = override.cost?.[this.key];
+    return value ? `${this.summaryTerm}: $${value}` : null;
+  }
+}

package/src/ui/editors/override/fields/index.ts

@@ -0,0 +1,68 @@
+import type { ModelCostRates } from "@earendil-works/pi-ai";
+import type { ModelOverride } from "../../../../interfaces/settings";
+import { FIELDS } from "../../../strings";
+import { OverrideField } from "./base";
+import { CapabilitiesField } from "./capabilities";
+import { CostField } from "./cost";
+import { NumericField } from "./numeric";
+import { PatternField } from "./pattern";
+import { ReasoningField } from "./reasoning";
+
+/** Cost field specs: [ModelCostRates key, FIELDS entry, summary term] */
+const COST_FIELDS: [
+  keyof ModelCostRates,
+  (
+    | typeof FIELDS.inputCost
+    | typeof FIELDS.outputCost
+    | typeof FIELDS.cacheReadCost
+    | typeof FIELDS.cacheWriteCost
+  ),
+  string,
+][] = [
+  ["input", FIELDS.inputCost, "input"],
+  ["output", FIELDS.outputCost, "output"],
+  ["cacheRead", FIELDS.cacheReadCost, "cache read"],
+  ["cacheWrite", FIELDS.cacheWriteCost, "cache write"],
+];
+
+/**
+ * The field registry for model override entries: the complete list of
+ * editable fields (order defines the row order in the settings list)
+ * plus id-based lookup. Throws on an unknown id — the registry is
+ * static, so a miss is a programming error.
+ */
+export class OverrideFields {
+  static readonly all: OverrideField[] = [
+    new PatternField(),
+    ...COST_FIELDS.map(
+      ([key, field, term]) => new CostField(`cost.${key}`, key, field, term),
+    ),
+    new CapabilitiesField(),
+    new ReasoningField(),
+    new NumericField("contextSize", FIELDS.contextSize),
+    new NumericField("maxTokens", FIELDS.maxTokens),
+  ];
+
+  static byId(id: string): OverrideField {
+    const field = this.all.find((f) => f.id === id);
+    if (!field) throw new Error(`Unknown override field: ${id}`);
+    return field;
+  }
+}
+
+/**
+ * Builds the entry-row summary shown in the override entry list
+ * (`input: $0.2, output: $0.6, cache read: $0.01, …`), composed from the
+ * {@link OverrideFields} registry — adding a field to the registry makes
+ * it show up here too, so the summary can't lag the edit menu. Fields
+ * with unset/zero values are omitted for brevity (each field decides via
+ * {@link OverrideField.summaryPart}); `—` when nothing is set.
+ */
+export class OverrideSummary {
+  static of(override: ModelOverride): string {
+    const parts = OverrideFields.all
+      .map((field) => field.summaryPart(override))
+      .filter((part): part is string => part !== null);
+    return parts.length > 0 ? parts.join(", ") : "—";
+  }
+}

package/src/ui/editors/override/fields/numeric.ts

@@ -0,0 +1,55 @@
+import type { ModelOverride } from "../../../../interfaces/settings";
+import type { Field } from "../../../strings";
+import { OverrideEntry } from "../entry";
+import type { InputValidator } from "./base";
+import { OverrideField } from "./base";
+
+/** Parses a non-negative number; blank input means zero (unset fields
+ * default to zero at read time). Returns `null` when invalid. */
+export function parseNonNegative(raw: string): number | null {
+  const n = Number(raw.trim());
+  return isFinite(n) && n >= 0 ? n : null;
+}
+
+/**
+ * Non-negative numeric field (`contextSize`, `maxTokens`): keeps the
+ * display format, validator and apply logic in a single place so the
+ * three can't drift (e.g. the validator accepting `0` while the apply
+ * drops it — unset fields default to zero at read time, so all render
+ * as `0`).
+ */
+export class NumericField extends OverrideField {
+  readonly type = "input";
+  override readonly field: Field;
+
+  constructor(
+    readonly id: "maxTokens" | "contextSize",
+    field: Field,
+  ) {
+    super();
+    this.field = field;
+  }
+
+  displayValue(entry: OverrideEntry): string {
+    return String(entry.override[this.id] ?? 0);
+  }
+
+  /** Accepts finite, non-negative numbers (blank means zero). */
+  readonly validate: InputValidator = (raw) => {
+    const n = parseNonNegative(raw);
+    return n === null ? null : String(n);
+  };
+
+  /** Applies the committed value; non-positive values remove the key. */
+  apply(override: ModelOverride, value: string): void {
+    const n = Number(value);
+    if (isFinite(n) && n > 0) override[this.id] = n;
+    else delete override[this.id];
+  }
+
+  /** Appears in the summary only when set. */
+  override summaryPart(override: ModelOverride): string | null {
+    const value = override[this.id];
+    return value === undefined ? null : `${this.id}: ${value}`;
+  }
+}

package/src/ui/editors/override/fields/pattern.ts

@@ -0,0 +1,24 @@
+import { FIELDS } from "../../../strings";
+import { OverrideEntry } from "../entry";
+import type { InputValidator } from "./base";
+import { OverrideField } from "./base";
+
+/**
+ * The entry's pattern key. Renames are handled by the editor
+ * (`OverrideEntryListEditor.applyFieldChange`), so {@link apply}
+ * inherits the base no-op.
+ */
+export class PatternField extends OverrideField {
+  readonly id = "pattern";
+  readonly type = "input";
+  readonly field = FIELDS.pattern;
+
+  displayValue(entry: OverrideEntry): string {
+    return entry.pattern;
+  }
+
+  readonly validate: InputValidator = (raw) => {
+    const trimmed = raw.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  };
+}

package/src/ui/editors/override/fields/reasoning.ts

@@ -0,0 +1,33 @@
+import type { ModelOverride } from "../../../../interfaces/settings";
+import { FIELDS } from "../../../strings";
+import { OverrideEntry } from "../entry";
+import type { InputValidator } from "./base";
+import { OverrideField } from "./base";
+
+/** The override's `reasoning` flag (finite: true/false, default true). */
+export class ReasoningField extends OverrideField {
+  readonly id = "reasoning";
+  readonly type = "finite";
+  readonly field = FIELDS.reasoning;
+  override readonly options = ["true", "false"];
+
+  displayValue(entry: OverrideEntry): string {
+    return entry.override.reasoning === false ? "false" : "true";
+  }
+
+  readonly validate: InputValidator = (raw) =>
+    this.options?.includes(raw) ? raw : null;
+
+  apply(override: ModelOverride, value: string): void {
+    if (value === "true") override.reasoning = true;
+    else if (value === "false") override.reasoning = false;
+    else delete override.reasoning;
+  }
+
+  /** Appears in the summary only when explicitly set. */
+  override summaryPart(override: ModelOverride): string | null {
+    return override.reasoning === undefined
+      ? null
+      : `reasoning: ${override.reasoning}`;
+  }
+}

package/src/ui/editors/override/itemBuilder.ts

@@ -2,7 +2,8 @@ import type { SettingItem } from "@earendil-works/pi-tui";
 import { FieldMessages, TITLES } from "../../strings";
 import { ItemBuilder } from "../itemBuilder";
 import { OverrideEntry } from "./entry";
-import { OverrideFields, type OverrideField } from "./fields";
+import type { OverrideField } from "./fields/base";
+import { OverrideFields } from "./fields/index";
 
 /**
  * Builds `SettingItem` objects for override entry field submenus.
@@ -20,11 +21,7 @@ export class OverrideItemBuilder extends ItemBuilder<
    * an `InputDialog` submenu (validating against the field definition)
    * for "input" fields.
    */
-  protected decorate(
-    def: OverrideField,
-    entry: OverrideEntry,
-    base: SettingItem,
-  ): SettingItem {
+  protected decorate(def: OverrideField, base: SettingItem): SettingItem {
     if (def.type === "finite") {
       return { ...base, values: [...(def.options ?? [])] };
     }

package/src/ui/editors/server/itemBuilder.ts

@@ -18,11 +18,7 @@ export class ServerItemBuilder extends ItemBuilder<LlamaServer, ServerField> {
    * Adds the field-edit submenu: an `InputDialog` validating against the
    * field definition.
    */
-  protected decorate(
-    def: ServerField,
-    server: LlamaServer,
-    base: SettingItem,
-  ): SettingItem {
+  protected decorate(def: ServerField, base: SettingItem): SettingItem {
     return {
       ...base,
       submenu: this.dialogs.inputSubmenu(

package/src/ui/editors/server/serverEditor.ts

@@ -3,11 +3,12 @@ import type { SettingItem, SettingsList } from "@earendil-works/pi-tui";
 import { SERVER_TIMEOUT } from "../../../constants";
 import type { LlamaServer } from "../../../interfaces/settings";
 import type { LlamaSettingsManager } from "../../../managers/settings";
-import { TITLES } from "../../strings";
+import { ServerIds } from "../../../utils/serverIds";
+import { TITLES, authRequiredMessage } from "../../strings";
 import type { ServerSettingsListOptions } from "../editorOptions";
 import { ListEditor } from "../listEditor";
 import { SettingsListFactory } from "../settingsListFactory";
-import { ServerEntryMutator } from "./handlers";
+import { ServerFields } from "./fields";
 import { ServerItemBuilder } from "./itemBuilder";
 import { ServerDisplay } from "./utils";
 import { ServerWizard } from "./wizard";
@@ -58,6 +59,15 @@ export class ServerSettingsList extends ListEditor<ServerSettingsListOptions> {
           done: () => done(undefined),
           onError: (message) => ui.notify(message, "error"),
           serverTimeout,
+          authResolver: async (server) => {
+            // Mirror Server.getApiKey(): use ServerIds.resolve to get
+            // the provider ID (customId or llama-server=<url>), then
+            // resolve the key from the credential store.
+            return settings.resolveApiKey(
+              ServerIds.resolve(server.url, server.id),
+            );
+          },
+          ui,
         }),
     );
   }
@@ -67,17 +77,24 @@ export class ServerSettingsList extends ListEditor<ServerSettingsListOptions> {
   protected async buildSettingsList(): Promise<SettingsList> {
     const builder = new ServerItemBuilder(this.dialogs);
     const serverTimeout = this.options.serverTimeout ?? SERVER_TIMEOUT;
-    const healthEmojis = await Promise.all(
-      this.options.servers.map((server) =>
-        ServerDisplay.healthEmoji(server.url, serverTimeout),
-      ),
+    // Run auth + health probes in parallel; ⛔ wins if auth fails,
+    // otherwise fall back to the health emoji.
+    const probes = await Promise.all(
+      this.options.servers.map(async (server) => {
+        const apiKey = (await this.options.authResolver?.(server)) ?? "";
+        const [authEmoji, healthEmoji] = await Promise.all([
+          ServerDisplay.authEmoji(server.url, apiKey, serverTimeout),
+          ServerDisplay.healthEmoji(server.url, serverTimeout),
+        ]);
+        return authEmoji || healthEmoji;
+      }),
     );
     const items: SettingItem[] = this.options.servers.map((server, i) =>
       builder.buildRow(
         server,
         i,
         (field, value) => this.handleFieldChange(field, value),
-        healthEmojis[i],
+        probes[i],
         // Opening delegates input to the submenu; closing flushes a
         // rebuild deferred by a field commit (see commitFieldChange)
         (open) => this.trackSubmenu(open),
@@ -92,10 +109,13 @@ export class ServerSettingsList extends ListEditor<ServerSettingsListOptions> {
   /** Handle a field commit from a server row's submenu. */
   private handleFieldChange(field: string, value: string): void {
     const idx = this.selectedIndex;
-    const next = new ServerEntryMutator(
-      this.options.servers,
-      idx,
-    ).applyFieldChange(field, value);
+    const server = this.options.servers[idx];
+    const updated = server
+      ? ServerFields.byId(field).apply(server, value)
+      : server;
+    const next = server
+      ? this.options.servers.map((s, i) => (i === idx ? updated : s))
+      : this.options.servers;
 
     this.commitFieldChange(next, idx, () => {
       // Refresh the row's suffix in place; the full rebuild (row labels
@@ -134,10 +154,6 @@ export class ServerSettingsList extends ListEditor<ServerSettingsListOptions> {
 
   protected readonly emptyHintKey = "emptyServers" as const;
 
-  protected getCurrentCount(): number {
-    return this.options.servers.length;
-  }
-
   protected getRowId(index: number): string {
     return `server-${index}`;
   }
@@ -157,5 +173,25 @@ export class ServerSettingsList extends ListEditor<ServerSettingsListOptions> {
     await this.persistSnapshot(next, () => {
       void this.rebuildList(next.length - 1);
     });
+
+    // Warn the user if the newly added server requires an API key
+    await this.warnIfAuthRequired(server);
+  }
+
+  /**
+   * Probes the server to check if it requires an API key. If so, notifies
+   * the user so they know to configure one via `/login` or `auth.json`.
+   */
+  private async warnIfAuthRequired(server: LlamaServer): Promise<void> {
+    const ui = this.options.ui;
+    if (!ui) return;
+
+    const serverTimeout = this.options.serverTimeout ?? SERVER_TIMEOUT;
+    const apiKey = (await this.options.authResolver?.(server)) ?? "";
+
+    if (await ServerDisplay.requiresApiKey(server.url, apiKey, serverTimeout)) {
+      const providerId = ServerIds.resolve(server.url, server.id);
+      ui.notify(authRequiredMessage(server.url, providerId), "warning");
+    }
   }
 }