pi-llama-cpp 0.11.0 → 0.12.0

package/tests/overrides.test.ts

@@ -0,0 +1,352 @@
+import { beforeEach, describe, expect, it } from "vitest";
+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 {
+  addOverrideEntry,
+  applyCostFieldValue,
+  formatOverrideSummary,
+  parseCostValue,
+  removeOverrideEntry,
+  updateOverrideEntry,
+} from "../src/ui/overrideEntryEditor";
+import { createMockServer, mockRpc } from "./mocks";
+
+beforeEach(() => {
+  mockRpc.mockReset();
+});
+
+const createModel = (overrides?: Record<string, ModelOverride>): SingleModel =>
+  new SingleModel(
+    {
+      id: "test",
+      tags: [],
+      object: "model",
+      owned_by: "test",
+      created: Date.now(),
+    },
+    createMockServer({ overrides }),
+  );
+
+/** Standard server responses: /props for capabilities, /v1/models for n_ctx */
+const mockDetection = (nCtx: number | undefined) =>
+  mockRpc.mockImplementation((endpoint: string) => {
+    if (endpoint.startsWith("/props")) {
+      return Promise.resolve({ modalities: { vision: false } });
+    }
+    return Promise.resolve({
+      data: [{ id: "test", meta: nCtx === undefined ? {} : { n_ctx: nCtx } }],
+    });
+  });
+
+// ─── Pattern matching (Server.findOverrideForModel) ───────────────────────
+
+describe("Server.findOverrideForModel", () => {
+  const makeServer = (overrides: Record<string, ModelOverride>): Server =>
+    createMockServer({ overrides });
+
+  it("should match a model by id prefix", () => {
+    const server = makeServer({ lla: { reasoning: false } });
+    expect(server.findOverrideForModel("llama-3")).toEqual({
+      reasoning: false,
+    });
+  });
+
+  it("should return undefined when no pattern matches", () => {
+    const server = makeServer({ qwen: { reasoning: false } });
+    expect(server.findOverrideForModel("llama-3")).toBeUndefined();
+  });
+
+  it("should prefer the longest (most specific) matching pattern", () => {
+    const server = makeServer({
+      llama: { reasoning: false },
+      "llama-3-8b": { reasoning: true, contextSize: 128 },
+    });
+    expect(server.findOverrideForModel("llama-3-8b")).toEqual({
+      reasoning: true,
+      contextSize: 128,
+    });
+    expect(server.findOverrideForModel("llama-3-70b")).toEqual({
+      reasoning: false,
+    });
+  });
+
+  it("should ignore empty patterns", () => {
+    const server = makeServer({ "": { reasoning: false } });
+    expect(server.findOverrideForModel("llama-3")).toBeUndefined();
+  });
+});
+
+// ─── reasoning override ────────────────────────────────────────────────────
+
+describe("BaseModel reasoning override", () => {
+  it("should default to true when no override matches", () => {
+    expect(createModel().reasoning).toBe(true);
+  });
+
+  it("should let the override win over the default", () => {
+    const model = createModel({ test: { reasoning: false } });
+    expect(model.reasoning).toBe(false);
+  });
+});
+
+// ─── capabilities override ────────────────────────────────────────────────
+
+describe("BaseModel capabilities override", () => {
+  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();
+
+    expect(capabilities).toEqual(["text", "image"]);
+    expect(mockRpc).not.toHaveBeenCalled();
+  });
+
+  it("should not intercept detection when no override matches", async () => {
+    mockDetection(8192);
+
+    const model = createModel({ other: { capabilities: ["text"] } });
+    const capabilities = await model.getCapabilities();
+
+    expect(capabilities).toEqual(["text"]);
+    expect(mockRpc).toHaveBeenCalled();
+  });
+});
+
+// ─── contextSize override ─────────────────────────────────────────────────
+
+describe("BaseModel.getContextSize with contextSize override", () => {
+  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();
+
+    expect(ctxSize).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();
+
+    expect(ctxSize).toBe(8192);
+  });
+
+  it("should autodetect when no override matches", async () => {
+    mockDetection(8192);
+
+    const model = createModel({ other: { contextSize: 32768 } });
+    const ctxSize = await model.getContextSize();
+
+    expect(ctxSize).toBe(8192);
+  });
+});
+
+// ─── toProviderConfig (cost, maxTokens, compat, precedence) ───────────────
+
+describe("toProviderConfig overrides", () => {
+  it("should merge a partial cost override with zero defaults", async () => {
+    mockDetection(8192);
+
+    const model = createModel({ test: { cost: { input: 0.2 } } });
+    const config = await model.toProviderConfig();
+
+    expect(config.cost).toEqual({
+      input: 0.2,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+    });
+  });
+
+  it("should default every cost field to zero without an override", async () => {
+    mockDetection(8192);
+
+    const model = createModel();
+    const config = await model.toProviderConfig();
+
+    expect(config.cost).toEqual({
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+    });
+  });
+
+  it("should pass a compat override through to the provider config", async () => {
+    mockDetection(8192);
+
+    const compat = {
+      supportsStore: false,
+      maxTokensField: "max_tokens",
+    } as const;
+    const model = createModel({ test: { compat } });
+    const config = await model.toProviderConfig();
+
+    expect(config.compat).toEqual(compat);
+  });
+
+  it("should leave compat undefined without an override", async () => {
+    mockDetection(8192);
+
+    const model = createModel();
+    const config = await model.toProviderConfig();
+
+    expect(config.compat).toBeUndefined();
+  });
+
+  it("should use the overridden context size for contextWindow and as the maxTokens fallback", async () => {
+    mockDetection(8192);
+
+    const model = createModel({ test: { contextSize: 32768 } });
+    const config = await model.toProviderConfig();
+
+    expect(config.contextWindow).toBe(32768);
+    expect(config.maxTokens).toBe(32768);
+  });
+
+  it("should prefer an explicit maxTokens override over the contextSize override", async () => {
+    mockDetection(8192);
+
+    const model = createModel({
+      test: { contextSize: 32768, maxTokens: 4096 },
+    });
+    const config = await model.toProviderConfig();
+
+    expect(config.contextWindow).toBe(32768);
+    expect(config.maxTokens).toBe(4096);
+  });
+
+  it("should use the detected context size when no override matches", async () => {
+    mockDetection(8192);
+
+    const model = createModel();
+    const config = await model.toProviderConfig();
+
+    expect(config.contextWindow).toBe(8192);
+    expect(config.maxTokens).toBe(8192);
+  });
+
+  it("should fall back to FALLBACK_CTX when the model is missing from detection", async () => {
+    mockRpc.mockImplementation((endpoint: string) => {
+      if (endpoint.startsWith("/props")) {
+        return Promise.resolve({ modalities: { vision: false } });
+      }
+      // /v1/models: no entry for this model → getContextSize throws → fallback
+      return Promise.resolve({ data: [] });
+    });
+
+    const model = createModel();
+    const config = await model.toProviderConfig();
+
+    expect(config.contextWindow).toBe(FALLBACK_CTX);
+    expect(config.maxTokens).toBe(FALLBACK_CTX);
+  });
+});
+
+// ─── formatOverrideSummary ────────────────────────────────────────────────
+
+describe("formatOverrideSummary", () => {
+  it("should render every configured field", () => {
+    const summary = formatOverrideSummary({
+      cost: { input: 0.2, output: 0.6, cacheRead: 0.01 },
+      capabilities: ["text", "image"],
+      reasoning: false,
+      contextSize: 32768,
+      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");
+  });
+
+  it("should omit zero, undefined and empty fields", () => {
+    const summary = formatOverrideSummary({
+      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");
+  });
+
+  it("should render an em dash for an empty override", () => {
+    expect(formatOverrideSummary({})).toBe("—");
+  });
+});
+
+// ─── override entry list helpers (overrideEntryEditor) ────────────────────
+
+describe("override entry list helpers", () => {
+  const servers = [
+    { url: "http://a", overrides: { "a-1": { reasoning: false } } },
+    { url: "http://b" },
+  ] as LlamaServer[];
+
+  it("addOverrideEntry should append a pattern → override entry", () => {
+    const next = addOverrideEntry(servers, 0, "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,
+    });
+    expect(Object.keys(next[0].overrides!)).toEqual(["a-renamed"]);
+    expect(next[0].overrides!["a-renamed"]).toEqual({ reasoning: true });
+    expect(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);
+    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("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("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("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("applyCostFieldValue should treat an empty override as unset cost", () => {
+    expect(applyCostFieldValue(undefined, "input", 0.5)).toEqual({
+      input: 0.5,
+    });
+  });
+});

package/tests/server.test.ts

@@ -154,16 +154,16 @@ describe("Server postRequest", () => {
   });
 });
 
-describe("Server timeouts", () => {
-  it("should resolve timeouts from the injected settings", () => {
+describe("Server timeouts", async () => {
+  it("should resolve timeouts from the injected settings", async () => {
     const server = new Server(settings, { baseUrl: "http://127.0.0.1:8080" });
 
-    expect(server.serverTimeout).toBe(SERVER_TIMEOUT);
-    expect(server.pollingTimeout).toBe(POLLING_TIMEOUT);
+    expect(await server.getServerTimeout()).toBe(SERVER_TIMEOUT);
+    expect(await server.getPollingTimeout()).toBe(POLLING_TIMEOUT);
   });
 
-  it("should return resolved custom values", () => {
-    vi.mocked(settings.resolveTimeouts).mockReturnValue({
+  it("should return resolved custom values", async () => {
+    vi.mocked(settings.resolveTimeouts).mockResolvedValue({
       pollingTimeout: 90000,
       serverTimeout: 2000,
     });
@@ -174,23 +174,23 @@ describe("Server timeouts", () => {
       customName: "My Server",
     });
 
-    expect(server.pollingTimeout).toBe(90000);
+    expect(await server.getPollingTimeout()).toBe(90000);
   });
 
-  it("should read timeouts live from settings", () => {
+  it("should read timeouts live from settings", async () => {
     const server = new Server(settings, { baseUrl: "http://127.0.0.1:8080" });
 
-    vi.mocked(settings.resolveTimeouts).mockReturnValue({
+    vi.mocked(settings.resolveTimeouts).mockResolvedValue({
       pollingTimeout: 120000,
       serverTimeout: 3000,
     });
-    expect(server.pollingTimeout).toBe(120000);
+    expect(await server.getPollingTimeout()).toBe(120000);
 
-    vi.mocked(settings.resolveTimeouts).mockReturnValue({
+    vi.mocked(settings.resolveTimeouts).mockResolvedValue({
       pollingTimeout: 90000,
       serverTimeout: 2000,
     });
-    expect(server.pollingTimeout).toBe(90000);
+    expect(await server.getPollingTimeout()).toBe(90000);
   });
 });
 

package/tests/serverManager.test.ts

@@ -27,7 +27,7 @@ const mockPi = {
  * `settings.resolveServers()` — the same path a real scan takes.
  */
 const createManager = async (...servers: Server[]): Promise<ServerManager> => {
-  vi.mocked(settingsStub.resolveServers).mockReturnValue(servers);
+  vi.mocked(settingsStub.resolveServers).mockResolvedValue(servers);
   const manager = new ServerManager(settingsStub);
   await manager.update(mockPi as any);
   return manager;
@@ -45,40 +45,6 @@ beforeEach(() => {
   });
 });
 
-describe("Server", () => {
-  it("should generate provider IDs from URLs", () => {
-    const server1 = new Server(settingsStub, {
-      baseUrl: "http://127.0.0.1:8080",
-    });
-    expect(server1.providerId).toBe("llama-server=http://127.0.0.1:8080");
-    const server2 = new Server(settingsStub, {
-      baseUrl: "http://10.0.0.5:8080",
-    });
-    expect(server2.providerId).toBe("llama-server=http://10.0.0.5:8080");
-    const server3 = new Server(settingsStub, { baseUrl: "http://127.0.0.1" });
-    expect(server3.providerId).toBe("llama-server=http://127.0.0.1");
-    const server4 = new Server(settingsStub, {
-      baseUrl: "http://127.0.0.1:80",
-    });
-    expect(server4.providerId).toBe("llama-server=http://127.0.0.1:80");
-    const server5 = new Server(settingsStub, {
-      baseUrl: "https://127.0.0.1:443",
-    });
-    expect(server5.providerId).toBe("llama-server=https://127.0.0.1:443");
-  });
-
-  it("should generate provider names from URLs", () => {
-    const server1 = new Server(settingsStub, {
-      baseUrl: "http://127.0.0.1:8080",
-    });
-    expect(server1.providerName).toBe("Llama.cpp (http://127.0.0.1:8080)");
-    const server2 = new Server(settingsStub, {
-      baseUrl: "http://10.0.0.5:8080",
-    });
-    expect(server2.providerName).toBe("Llama.cpp (http://10.0.0.5:8080)");
-  });
-});
-
 describe("ServerManager", () => {
   it("should register providers for all servers", async () => {
     const mockModel = {
@@ -134,7 +100,7 @@ describe("ServerManager", () => {
     });
     const manager = await createManager(server1, server2);
 
-    const allModels = manager.getAllModels();
+    const allModels = await manager.getAllModels();
 
     expect(allModels).toHaveLength(2);
     expect(allModels[0]).toBe(mockModel1);
@@ -153,13 +119,13 @@ describe("ServerManager", () => {
 
     it("should register servers added after the first scan", async () => {
       const server1 = makeServer("http://127.0.0.1:8080", "model-1");
-      vi.mocked(settingsStub.resolveServers).mockReturnValue([server1]);
+      vi.mocked(settingsStub.resolveServers).mockResolvedValue([server1]);
       const manager = new ServerManager(settingsStub);
       await manager.update(mockPi as any);
       expect(manager.servers).toHaveLength(1);
 
       const server2 = makeServer("http://127.0.0.1:8081", "model-2");
-      vi.mocked(settingsStub.resolveServers).mockReturnValue([
+      vi.mocked(settingsStub.resolveServers).mockResolvedValue([
         server1,
         server2,
       ]);
@@ -170,10 +136,8 @@ describe("ServerManager", () => {
         expect.objectContaining({ baseUrl: "http://127.0.0.1:8081" }),
       );
       expect(manager.servers).toHaveLength(2);
-      expect(manager.getAllModels().map((m) => m.id)).toEqual([
-        "model-1",
-        "model-2",
-      ]);
+      const models = await manager.getAllModels();
+      expect(models.map((m) => m.id)).toEqual(["model-1", "model-2"]);
     });
 
     it("should unregister and disconnect removed servers on the next scan", async () => {
@@ -190,7 +154,7 @@ describe("ServerManager", () => {
       const manager = await createManager(server1, server2);
       expect(manager.servers).toHaveLength(2);
 
-      vi.mocked(settingsStub.resolveServers).mockReturnValue([server1]);
+      vi.mocked(settingsStub.resolveServers).mockResolvedValue([server1]);
       await manager.update(mockPi as any);
 
       expect(mockPi.unregisterProvider).toHaveBeenCalledTimes(1);
@@ -200,7 +164,9 @@ describe("ServerManager", () => {
       expect(disconnectRemoved).toHaveBeenCalledTimes(1);
       // Surviving providers keep their SSE manager connected (today's behavior)
       expect(disconnectKept).not.toHaveBeenCalled();
-      expect(manager.getAllModels().map((m) => m.id)).toEqual(["model-1"]);
+      expect((await manager.getAllModels()).map((m) => m.id)).toEqual([
+        "model-1",
+      ]);
     });
 
     it("should unregister the old provider when a server URL changes", async () => {
@@ -208,7 +174,7 @@ describe("ServerManager", () => {
         makeServer("http://127.0.0.1:8080", "model-1"),
       );
 
-      vi.mocked(settingsStub.resolveServers).mockReturnValue([
+      vi.mocked(settingsStub.resolveServers).mockResolvedValue([
         makeServer("http://127.0.0.1:9090", "model-1"),
       ]);
       await manager.update(mockPi as any);
@@ -238,7 +204,7 @@ describe("ServerManager", () => {
         customId: "my-custom-id",
         customName: "B",
       });
-      vi.mocked(settingsStub.resolveServers).mockReturnValue([renamed]);
+      vi.mocked(settingsStub.resolveServers).mockResolvedValue([renamed]);
       await manager.update(mockPi as any);
 
       expect(mockPi.unregisterProvider).not.toHaveBeenCalled();
@@ -256,7 +222,7 @@ describe("ServerManager", () => {
 
       expect(manager.servers).toHaveLength(1);
       expect(mockPi.registerProvider).toHaveBeenCalledTimes(1);
-      expect(manager.getAllModels()).toHaveLength(1);
+      expect(await manager.getAllModels()).toHaveLength(1);
     });
 
     it("should return undefined from getServer for a removed server's model", async () => {
@@ -264,7 +230,7 @@ describe("ServerManager", () => {
         makeServer("http://127.0.0.1:8080", "model-1"),
       );
 
-      const live = manager.getAllModels()[0];
+      const live = (await manager.getAllModels())[0];
       expect(manager.getServer(live)).toBe(manager.servers[0]);
 
       const orphan = { serverUrl: "http://gone:1" } as unknown as BaseModel;
@@ -276,7 +242,7 @@ describe("ServerManager", () => {
     const sortBy = () => vi.mocked(settingsStub.resolveSortBy);
 
     it("should return models in API order when sortBy is 'api'", async () => {
-      sortBy().mockReturnValue("api");
+      sortBy().mockResolvedValue("api");
 
       const mockModelA = createMockModel("model-a");
       const mockModelZ = createMockModel("model-z");
@@ -287,7 +253,7 @@ describe("ServerManager", () => {
         }),
       );
 
-      const allModels = manager.getAllModels();
+      const allModels = await manager.getAllModels();
 
       expect(allModels).toHaveLength(2);
       expect(allModels[0]).toBe(mockModelA);
@@ -295,7 +261,7 @@ describe("ServerManager", () => {
     });
 
     it("should sort models by ID ascending when sortBy is 'asc'", async () => {
-      sortBy().mockReturnValue("asc");
+      sortBy().mockResolvedValue("asc");
 
       const mockModelZ = createMockModel("model-z");
       const mockModelA = createMockModel("model-a");
@@ -306,7 +272,7 @@ describe("ServerManager", () => {
         }),
       );
 
-      const allModels = manager.getAllModels();
+      const allModels = await manager.getAllModels();
 
       expect(allModels).toHaveLength(2);
       expect(allModels[0]).toBe(mockModelA);
@@ -314,7 +280,7 @@ describe("ServerManager", () => {
     });
 
     it("should sort models by ID descending when sortBy is 'desc'", async () => {
-      sortBy().mockReturnValue("desc");
+      sortBy().mockResolvedValue("desc");
 
       const mockModelA = createMockModel("model-a");
       const mockModelZ = createMockModel("model-z");
@@ -325,7 +291,7 @@ describe("ServerManager", () => {
         }),
       );
 
-      const allModels = manager.getAllModels();
+      const allModels = await manager.getAllModels();
 
       expect(allModels).toHaveLength(2);
       expect(allModels[0]).toBe(mockModelZ);
@@ -333,7 +299,7 @@ describe("ServerManager", () => {
     });
 
     it("should sort models by name ascending when sortBy is 'asc-name'", async () => {
-      sortBy().mockReturnValue("asc-name");
+      sortBy().mockResolvedValue("asc-name");
 
       const mockModelB = createMockModel("zebra", { id: "model-b" });
       const mockModelA = createMockModel("alpha", { id: "model-a" });
@@ -344,7 +310,7 @@ describe("ServerManager", () => {
         }),
       );
 
-      const allModels = manager.getAllModels();
+      const allModels = await manager.getAllModels();
 
       expect(allModels).toHaveLength(2);
       expect(allModels[0]).toBe(mockModelA);
@@ -352,7 +318,7 @@ describe("ServerManager", () => {
     });
 
     it("should sort models by name descending when sortBy is 'desc-name'", async () => {
-      sortBy().mockReturnValue("desc-name");
+      sortBy().mockResolvedValue("desc-name");
 
       const mockModelA = createMockModel("alpha", { id: "model-a" });
       const mockModelB = createMockModel("zebra", { id: "model-b" });
@@ -363,7 +329,7 @@ describe("ServerManager", () => {
         }),
       );
 
-      const allModels = manager.getAllModels();
+      const allModels = await manager.getAllModels();
 
       expect(allModels).toHaveLength(2);
       expect(allModels[0]).toBe(mockModelB);