pi-llama-cpp 0.12.0 → 0.14.0

package/tests/dialog.test.ts

@@ -5,8 +5,10 @@ import {
   type TUI,
 } from "@earendil-works/pi-tui";
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import { ConfirmDialog, InputDialog } from "../src/ui/dialog";
-import { ServerSettingsList } from "../src/ui/serverSettingsList";
+import { ConfirmDialog } from "../src/ui/dialog/confirm";
+import { InputDialog } from "../src/ui/dialog/input";
+import { OverrideSettingsList } from "../src/ui/editors/override/overrideList";
+import { ServerSettingsList } from "../src/ui/editors/server/serverEditor";
 
 beforeEach(() => {
   initTheme();
@@ -184,3 +186,94 @@ 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 = new OverrideSettingsList({
+      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");
+  });
+});
+
+describe("OverrideSettingsList escape navigation", () => {
+  const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+  const build = () => {
+    const done = vi.fn();
+    const list = new OverrideSettingsList({
+      tui: createMockTui(),
+      theme: createMockTheme(),
+      keybindings: createKeybindings(),
+      servers: [
+        {
+          url: "http://x:1",
+          overrides: { "gpt-*": { cost: { input: 0.2 } } },
+        },
+      ] as never[],
+      persist: vi.fn().mockResolvedValue(undefined),
+      done,
+      onError: vi.fn(),
+      onChanged: vi.fn(),
+    });
+    return { list, done };
+  };
+
+  it("Esc from the field submenu then the entry list lands on the server list", async () => {
+    const { list, done } = build();
+
+    list.handleInput(ENTER); // drill into the server row (entry list)
+    list.handleInput(ENTER); // open the field submenu
+    expect(list.render(80).join("\n")).not.toContain("http://x:1");
+
+    list.handleInput(ESC); // field submenu → entry list
+    await flush();
+    expect(done).not.toHaveBeenCalled();
+    expect(list.render(80).join("\n")).not.toContain("http://x:1");
+
+    list.handleInput(ESC); // entry list → server list
+    await flush();
+    // The dialog must stay open, showing the server row again
+    expect(done).not.toHaveBeenCalled();
+    expect(list.render(80).join("\n")).toContain("http://x:1");
+  });
+
+  it("Esc from the server list closes the dialog", async () => {
+    const { list, done } = build();
+
+    list.handleInput(ESC);
+    expect(done).toHaveBeenCalledTimes(1);
+  });
+});

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/legacyModel.test.ts

@@ -1,4 +1,5 @@
 import { beforeEach, describe, expect, it } from "vitest";
+import { FALLBACK_CTX } from "../src/constants";
 import { Mode } from "../src/enums/mode";
 import { DataProperty } from "../src/interfaces/endpoints/models";
 import { LegacyModel } from "../src/models/legacyModel";
@@ -28,70 +29,75 @@ describe("LegacyModel mode", () => {
   });
 });
 
-describe("LegacyModel capabilities", () => {
+describe("LegacyModel capabilities (via toProviderConfig)", () => {
   it("should detect image capability when multimodal is in capabilities", async () => {
     mockRpc.mockResolvedValueOnce({ modalities: { vision: true } });
+    mockRpc.mockResolvedValue({ n_ctx: 4096, data: [{ max_model_len: 8192 }] });
 
     const model = createModel();
-    const capabilities = await model.getCapabilities();
+    const { input } = await model.toProviderConfig();
 
-    expect(capabilities).toEqual(["text", "image"]);
+    expect(input).toEqual(["text", "image"]);
   });
 
   it("should detect text-only capability when multimodal is not in capabilities", async () => {
     mockRpc.mockResolvedValueOnce({ modalities: { vision: false } });
+    mockRpc.mockResolvedValue({ n_ctx: 4096, data: [{ max_model_len: 8192 }] });
 
     const model = createModel();
-    const capabilities = await model.getCapabilities();
+    const { input } = await model.toProviderConfig();
 
-    expect(capabilities).toEqual(["text"]);
+    expect(input).toEqual(["text"]);
   });
 
   it("should fall back to text-only when auth fails", async () => {
-    mockRpc.mockRejectedValue(new Error("401 Unauthorized"));
+    mockRpc.mockRejectedValueOnce(new Error("401 Unauthorized")); // /props
+    mockRpc.mockRejectedValueOnce(new Error("401 Unauthorized")); // /v1/models in BaseModel's catch
+    mockRpc.mockResolvedValue({
+      n_ctx: 4096,
+      data: [{ max_model_len: 8192 }],
+      models: [{ capabilities: ["text"] }],
+    });
 
     const model = createModel();
-    const capabilities = await model.getCapabilities();
+    const { input } = await model.toProviderConfig();
 
-    expect(capabilities).toEqual(["text"]);
+    expect(input).toEqual(["text"]);
   });
 });
 
-describe("LegacyModel getContextSize", () => {
+describe("LegacyModel context size (via toProviderConfig)", () => {
   it("should use max_model_len when it is non-zero", async () => {
-    mockRpc.mockResolvedValueOnce({ n_ctx: 4096 });
-    mockRpc.mockResolvedValueOnce({
-      data: [{ max_model_len: 8192 }],
-    });
+    mockRpc.mockResolvedValueOnce({ modalities: { vision: false } }); // capabilities: /props
+    mockRpc.mockResolvedValueOnce({ n_ctx: 4096 }); // /props
+    mockRpc.mockResolvedValueOnce({ data: [{ max_model_len: 8192 }] }); // /v1/models
 
     const model = createModel();
-    const ctxSize = await model.getContextSize();
+    const { contextWindow } = await model.toProviderConfig();
 
-    expect(ctxSize).toBe(8192);
+    expect(contextWindow).toBe(8192);
     expect(mockRpc).toHaveBeenCalledWith("/v1/models");
   });
 
   it("should fall back to n_ctx when max_model_len is 0", async () => {
-    mockRpc.mockResolvedValueOnce({ n_ctx: 4096 });
-    mockRpc.mockResolvedValueOnce({
-      data: [{ max_model_len: 0 }],
-    });
+    mockRpc.mockResolvedValueOnce({ modalities: { vision: false } }); // capabilities: /props
+    mockRpc.mockResolvedValueOnce({ n_ctx: 4096 }); // /props
+    mockRpc.mockResolvedValueOnce({ data: [{ max_model_len: 0 }] }); // /v1/models
 
     const model = createModel();
-    const ctxSize = await model.getContextSize();
+    const { contextWindow } = await model.toProviderConfig();
 
-    expect(ctxSize).toBe(4096);
+    expect(contextWindow).toBe(4096);
   });
 
-  it("should return DEFAULT_CTX when both values are missing/null", async () => {
-    mockRpc.mockResolvedValueOnce({});
-    mockRpc.mockResolvedValueOnce({
-      data: [{ max_model_len: null }],
-    });
+  it("should return FALLBACK_CTX when both values are missing/null", async () => {
+    mockRpc.mockResolvedValueOnce({ modalities: { vision: false } }); // capabilities: /props
+    mockRpc.mockResolvedValueOnce({}); // /props
+    mockRpc.mockResolvedValueOnce({ data: [{ max_model_len: null }] }); // /v1/models
 
     const model = createModel();
-    const ctxSize = await model.getContextSize();
+    const { contextWindow } = await model.toProviderConfig();
 
-    expect(ctxSize).toBe(128000);
+    expect(contextWindow).toBe(FALLBACK_CTX);
   });
 });

package/tests/overrides.test.ts

@@ -3,14 +3,12 @@ import { FALLBACK_CTX } from "../src/constants";
 import type { LlamaServer, ModelOverride } from "../src/interfaces/settings";
 import { SingleModel } from "../src/models/singleModel";
 import { Server } from "../src/server";
+import { OverrideEntry } from "../src/ui/editors/override/entry";
 import {
-  addOverrideEntry,
-  applyCostFieldValue,
-  formatOverrideSummary,
-  parseCostValue,
-  removeOverrideEntry,
-  updateOverrideEntry,
-} from "../src/ui/overrideEntryEditor";
+  OverrideFields,
+  OverrideSummary,
+} from "../src/ui/editors/override/fields";
+import { OverrideEntryMutator } from "../src/ui/editors/override/handlers";
 import { createMockServer, mockRpc } from "./mocks";
 
 beforeEach(() => {
@@ -93,16 +91,18 @@ describe("BaseModel reasoning override", () => {
 
 // ─── capabilities override ────────────────────────────────────────────────
 
-describe("BaseModel capabilities override", () => {
+describe("BaseModel capabilities override (via toProviderConfig)", () => {
   it("should fully replace detection without contacting the server", async () => {
     mockRpc.mockImplementation(() => {
       throw new Error("override must not trigger a fetch");
     });
 
-    const model = createModel({ test: { capabilities: ["text", "image"] } });
-    const capabilities = await model.getCapabilities();
+    const model = createModel({
+      test: { capabilities: ["text", "image"], contextSize: 8192 },
+    });
+    const { input } = await model.toProviderConfig();
 
-    expect(capabilities).toEqual(["text", "image"]);
+    expect(input).toEqual(["text", "image"]);
     expect(mockRpc).not.toHaveBeenCalled();
   });
 
@@ -110,41 +110,41 @@ describe("BaseModel capabilities override", () => {
     mockDetection(8192);
 
     const model = createModel({ other: { capabilities: ["text"] } });
-    const capabilities = await model.getCapabilities();
+    const { input } = await model.toProviderConfig();
 
-    expect(capabilities).toEqual(["text"]);
+    expect(input).toEqual(["text"]);
     expect(mockRpc).toHaveBeenCalled();
   });
 });
 
 // ─── contextSize override ─────────────────────────────────────────────────
 
-describe("BaseModel.getContextSize with contextSize override", () => {
+describe("BaseModel contextSize override (via toProviderConfig)", () => {
   it("should return the overridden context size instead of the detected one", async () => {
     mockDetection(8192);
 
     const model = createModel({ test: { contextSize: 32768 } });
-    const ctxSize = await model.getContextSize();
+    const { contextWindow } = await model.toProviderConfig();
 
-    expect(ctxSize).toBe(32768);
+    expect(contextWindow).toBe(32768);
   });
 
   it("should treat a stored 0 as absent and autodetect", async () => {
     mockDetection(8192);
 
     const model = createModel({ test: { contextSize: 0 } });
-    const ctxSize = await model.getContextSize();
+    const { contextWindow } = await model.toProviderConfig();
 
-    expect(ctxSize).toBe(8192);
+    expect(contextWindow).toBe(8192);
   });
 
   it("should autodetect when no override matches", async () => {
     mockDetection(8192);
 
     const model = createModel({ other: { contextSize: 32768 } });
-    const ctxSize = await model.getContextSize();
+    const { contextWindow } = await model.toProviderConfig();
 
-    expect(ctxSize).toBe(8192);
+    expect(contextWindow).toBe(8192);
   });
 });
 
@@ -250,11 +250,14 @@ describe("toProviderConfig overrides", () => {
   });
 });
 
-// ─── formatOverrideSummary ────────────────────────────────────────────────
+// ─── OverrideEntry.summary ────────────────────────────────────────────────────
+
+describe("OverrideSummary.of", () => {
+  const summary = (override: ModelOverride): string =>
+    OverrideSummary.of(override);
 
-describe("formatOverrideSummary", () => {
   it("should render every configured field", () => {
-    const summary = formatOverrideSummary({
+    const rendered = summary({
       cost: { input: 0.2, output: 0.6, cacheRead: 0.01 },
       capabilities: ["text", "image"],
       reasoning: false,
@@ -262,31 +265,31 @@ describe("formatOverrideSummary", () => {
       maxTokens: 4096,
     });
 
-    expect(summary).toContain("input: $0.2");
-    expect(summary).toContain("output: $0.6");
-    expect(summary).toContain("cache read: $0.01");
-    expect(summary).toContain("capabilities: text,image");
-    expect(summary).toContain("reasoning: false");
-    expect(summary).toContain("contextSize: 32768");
-    expect(summary).toContain("maxTokens: 4096");
+    expect(rendered).toContain("input: $0.2");
+    expect(rendered).toContain("output: $0.6");
+    expect(rendered).toContain("cache read: $0.01");
+    expect(rendered).toContain("capabilities: text,image");
+    expect(rendered).toContain("reasoning: false");
+    expect(rendered).toContain("contextSize: 32768");
+    expect(rendered).toContain("maxTokens: 4096");
   });
 
   it("should omit zero, undefined and empty fields", () => {
-    const summary = formatOverrideSummary({
+    const rendered = summary({
       cost: { input: 0, output: 0.6 },
       reasoning: undefined,
     });
 
-    expect(summary).not.toContain("input:");
-    expect(summary).toContain("output: $0.6");
-    expect(summary).not.toContain("capabilities");
-    expect(summary).not.toContain("reasoning");
-    expect(summary).not.toContain("contextSize");
-    expect(summary).not.toContain("maxTokens");
+    expect(rendered).not.toContain("input:");
+    expect(rendered).toContain("output: $0.6");
+    expect(rendered).not.toContain("capabilities");
+    expect(rendered).not.toContain("reasoning");
+    expect(rendered).not.toContain("contextSize");
+    expect(rendered).not.toContain("maxTokens");
   });
 
   it("should render an em dash for an empty override", () => {
-    expect(formatOverrideSummary({})).toBe("—");
+    expect(summary({})).toBe("—");
   });
 });
 
@@ -298,55 +301,107 @@ describe("override entry list helpers", () => {
     { url: "http://b" },
   ] as LlamaServer[];
 
-  it("addOverrideEntry should append a pattern → override entry", () => {
-    const next = addOverrideEntry(servers, 0, "a-2", { contextSize: 4096 });
+  it("addEntry should append a pattern → override entry", () => {
+    const next = new OverrideEntryMutator(servers, 0).addEntry("a-2", {
+      contextSize: 4096,
+    });
     expect(next[0].overrides).toEqual({
       "a-1": { reasoning: false },
       "a-2": { contextSize: 4096 },
     });
   });
 
-  it("updateOverrideEntry should replace in place without reordering", () => {
-    const next = updateOverrideEntry(servers, 0, 0, "a-renamed", {
-      reasoning: true,
+  it("pattern renames should replace in place without reordering", () => {
+    const mutator = new OverrideEntryMutator(servers, 0);
+    const result = mutator.applyFieldChange(0, "pattern", "a-renamed");
+    expect(result).not.toBeNull();
+    expect(Object.keys(result!.next[0].overrides!)).toEqual(["a-renamed"]);
+    expect(result!.next[0].overrides!["a-renamed"]).toEqual({
+      reasoning: false,
     });
-    expect(Object.keys(next[0].overrides!)).toEqual(["a-renamed"]);
-    expect(next[0].overrides!["a-renamed"]).toEqual({ reasoning: true });
-    expect(next[1]).toBe(servers[1]);
+    expect(result!.next[1]).toBe(servers[1]);
   });
 
-  it("removeOverrideEntry should drop only the targeted entry", () => {
-    const withTwo = addOverrideEntry(servers, 0, "a-2", {});
-    const next = removeOverrideEntry(withTwo, 0, 0);
+  it("removeEntry should drop only the targeted entry", () => {
+    const withTwo = new OverrideEntryMutator(servers, 0).addEntry("a-2");
+    const next = new OverrideEntryMutator(withTwo, 0).removeEntry(0);
     expect(Object.keys(next[0].overrides!)).toEqual(["a-2"]);
   });
 
-  it("parseCostValue should accept blank, non-negative numbers; reject the rest", () => {
-    expect(parseCostValue("")).toBe(0);
-    expect(parseCostValue("  0.5 ")).toBe(0.5);
-    expect(parseCostValue("-1")).toBeNull();
-    expect(parseCostValue("abc")).toBeNull();
-    expect(parseCostValue("Infinity")).toBeNull();
+  it("CostField.validate should accept blank, non-negative numbers; reject the rest", () => {
+    const cost = OverrideFields.byId("cost.input");
+    expect(cost.validate("")).toBe("0");
+    expect(cost.validate("  0.5 ")).toBe("0.5");
+    expect(cost.validate("-1")).toBeNull();
+    expect(cost.validate("abc")).toBeNull();
+    expect(cost.validate("Infinity")).toBeNull();
   });
 
-  it("applyCostFieldValue should set a positive value, keeping other fields", () => {
-    const next = applyCostFieldValue({ input: 0.2 }, "output", 0.6);
-    expect(next).toEqual({ input: 0.2, output: 0.6 });
+  it("CostField.apply should set a positive value, keeping other fields", () => {
+    const override: ModelOverride = { cost: { input: 0.2 } };
+    OverrideFields.byId("cost.output").apply(override, "0.6");
+    expect(override.cost).toEqual({ input: 0.2, output: 0.6 });
   });
 
-  it("applyCostFieldValue should remove the field on zero", () => {
-    const next = applyCostFieldValue({ input: 0.2, output: 0.6 }, "input", 0);
-    expect(next).toEqual({ output: 0.6 });
+  it("CostField.apply should remove the field on zero", () => {
+    const override: ModelOverride = { cost: { input: 0.2, output: 0.6 } };
+    OverrideFields.byId("cost.input").apply(override, "0");
+    expect(override.cost).toEqual({ output: 0.6 });
   });
 
-  it("applyCostFieldValue should return undefined when the last field is zeroed", () => {
-    expect(applyCostFieldValue({ input: 0.2 }, "input", 0)).toBeUndefined();
-    expect(applyCostFieldValue(undefined, "input", 0)).toBeUndefined();
+  it("CostField.apply should drop the whole cost object when the last field is zeroed", () => {
+    const single: ModelOverride = { cost: { input: 0.2 } };
+    OverrideFields.byId("cost.input").apply(single, "0");
+    expect(single.cost).toBeUndefined();
+
+    const empty: ModelOverride = {};
+    OverrideFields.byId("cost.input").apply(empty, "0");
+    expect(empty.cost).toBeUndefined();
   });
 
-  it("applyCostFieldValue should treat an empty override as unset cost", () => {
-    expect(applyCostFieldValue(undefined, "input", 0.5)).toEqual({
-      input: 0.5,
-    });
+  it("CostField.apply should treat an empty override as unset cost", () => {
+    const override: ModelOverride = {};
+    OverrideFields.byId("cost.input").apply(override, "0.5");
+    expect(override.cost).toEqual({ input: 0.5 });
+  });
+});
+
+describe("OverrideField.displayValue", () => {
+  const display = (id: string, override: ModelOverride): string =>
+    OverrideFields.byId(id).displayValue(new OverrideEntry("gpt-*", override));
+
+  it("formats cost fields, defaulting to 0", () => {
+    expect(display("cost.input", {})).toBe("0");
+    expect(display("cost.input", { cost: { input: 0.2 } })).toBe("0.2");
+    expect(display("cost.cacheWrite", {})).toBe("0");
+  });
+
+  it("formats capabilities and reasoning labels", () => {
+    expect(display("capabilities", {})).toBe("text");
+    expect(display("capabilities", { capabilities: ["text", "image"] })).toBe(
+      "text | image",
+    );
+    expect(display("reasoning", {})).toBe("true");
+    expect(display("reasoning", { reasoning: false })).toBe("false");
+  });
+
+  it("formats maxTokens/contextSize, defaulting to 0", () => {
+    expect(display("maxTokens", {})).toBe("0");
+    expect(display("maxTokens", { maxTokens: 4096 })).toBe("4096");
+    expect(display("contextSize", { contextSize: 8192 })).toBe("8192");
+  });
+
+  it("returns the entry's pattern for the pattern field", () => {
+    expect(
+      OverrideFields.byId("pattern").displayValue(
+        new OverrideEntry("gpt-*", {}),
+      ),
+    ).toBe("gpt-*");
+  });
+
+  it("throws for unknown fields", () => {
+    expect(() => OverrideFields.byId("other")).toThrow(
+      "Unknown override field: other",
+    );
   });
 });