pi-llama-cpp 0.13.0 → 0.14.0

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,15 +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";
-import { overrideFieldValue } from "../src/ui/overrideSettingsList";
+  OverrideFields,
+  OverrideSummary,
+} from "../src/ui/editors/override/fields";
+import { OverrideEntryMutator } from "../src/ui/editors/override/handlers";
 import { createMockServer, mockRpc } from "./mocks";
 
 beforeEach(() => {
@@ -94,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();
   });
 
@@ -111,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);
   });
 });
 
@@ -251,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,
@@ -263,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("—");
   });
 });
 
@@ -299,86 +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("overrideFieldValue", () => {
+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(overrideFieldValue("cost.input", {})).toBe("0");
-    expect(overrideFieldValue("cost.input", { cost: { input: 0.2 } })).toBe(
-      "0.2",
-    );
-    expect(overrideFieldValue("cost.cacheWrite", {})).toBe("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(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");
+    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(overrideFieldValue("maxTokens", {})).toBe("0");
-    expect(overrideFieldValue("maxTokens", { maxTokens: 4096 })).toBe("4096");
-    expect(overrideFieldValue("contextSize", { contextSize: 8192 })).toBe(
-      "8192",
-    );
+    expect(display("maxTokens", {})).toBe("0");
+    expect(display("maxTokens", { maxTokens: 4096 })).toBe("4096");
+    expect(display("contextSize", { contextSize: 8192 })).toBe("8192");
   });
 
-  it("returns an empty label for unknown fields", () => {
-    expect(overrideFieldValue("other", {})).toBe("");
+  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",
+    );
   });
 });