pi-llama-cpp 0.12.0 → 0.14.0

package/tests/routerModel.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 { RouterModel } from "../src/models/routerModel";
@@ -20,12 +21,21 @@ beforeEach(() => {
   mockRpc.mockClear();
 });
 
-describe("RouterModel context size extraction", () => {
-  it("should extract --ctx-size value", () => {
+describe("RouterModel context size (via toProviderConfig)", () => {
+  /** Mocks for an unloaded model: capabilities detection fails (text-only),
+   * then the status probe fails so context size falls back to CLI args. */
+  const mockUnloaded = () => {
+    mockRpc.mockRejectedValueOnce(new Error("props not available")); // capabilities: /props
+    mockRpc.mockResolvedValueOnce({ data: [] }); // capabilities: /v1/models
+    mockRpc.mockRejectedValueOnce(new Error("props not available")); // status: /props
+  };
+
+  it("should extract --ctx-size when unloaded", async () => {
+    mockUnloaded();
     const model = new RouterModel(
       createModel({
         status: {
-          value: "loaded",
+          value: "unloaded",
           args: [
             "--model",
             "gguf",
@@ -40,16 +50,17 @@ describe("RouterModel context size extraction", () => {
       createMockServer(),
     );
 
-    // Access the private method via any
-    const extractFrom = (model as any).extractFrom.bind(model);
-    expect(extractFrom("--ctx-size")).toBe(4096);
+    const { contextWindow } = await model.toProviderConfig();
+
+    expect(contextWindow).toBe(4096);
   });
 
-  it("should extract --fit-ctx value when --ctx-size is not present", () => {
+  it("should fall back to --fit-ctx when --ctx-size is not present", async () => {
+    mockUnloaded();
     const model = new RouterModel(
       createModel({
         status: {
-          value: "loaded",
+          value: "unloaded",
           args: ["--model", "gguf", "--fit-ctx", "8192"],
           preset: "default",
         },
@@ -57,91 +68,87 @@ describe("RouterModel context size extraction", () => {
       createMockServer(),
     );
 
-    const extractFrom = (model as any).extractFrom.bind(model);
-    expect(extractFrom("--fit-ctx")).toBe(8192);
+    const { contextWindow } = await model.toProviderConfig();
+
+    expect(contextWindow).toBe(8192);
   });
 
-  it("should return null when argument is not found", () => {
+  it("should prefer --ctx-size over --fit-ctx", async () => {
+    mockUnloaded();
     const model = new RouterModel(
       createModel({
         status: {
-          value: "loaded",
-          args: ["--model", "gguf", "--batch-size", "512"],
+          value: "unloaded",
+          args: ["--model", "gguf", "--ctx-size", "4096", "--fit-ctx", "8192"],
           preset: "default",
         },
       }),
       createMockServer(),
     );
 
-    const extractFrom = (model as any).extractFrom.bind(model);
-    expect(extractFrom("--ctx-size")).toBeNull();
-    expect(extractFrom("--fit-ctx")).toBeNull();
+    const { contextWindow } = await model.toProviderConfig();
+
+    expect(contextWindow).toBe(4096);
   });
 
-  it("should return null when argument has no following value", () => {
+  it("should fall back to FALLBACK_CTX when no size argument is present", async () => {
+    mockUnloaded();
     const model = new RouterModel(
       createModel({
         status: {
-          value: "loaded",
-          args: ["--model", "gguf", "--ctx-size"],
+          value: "unloaded",
+          args: ["--model", "gguf", "--batch-size", "512"],
           preset: "default",
         },
       }),
       createMockServer(),
     );
 
-    const extractFrom = (model as any).extractFrom.bind(model);
-    expect(extractFrom("--ctx-size")).toBeNull();
+    const { contextWindow } = await model.toProviderConfig();
+
+    expect(contextWindow).toBe(FALLBACK_CTX);
   });
 
-  it("should return null when argument value is not a valid number", () => {
+  it("should fall back to FALLBACK_CTX when the argument has no following value", async () => {
+    mockUnloaded();
     const model = new RouterModel(
       createModel({
         status: {
-          value: "loaded",
-          args: ["--model", "gguf", "--ctx-size", "not-a-number"],
+          value: "unloaded",
+          args: ["--model", "gguf", "--ctx-size"],
           preset: "default",
         },
       }),
       createMockServer(),
     );
 
-    const extractFrom = (model as any).extractFrom.bind(model);
-    expect(extractFrom("--ctx-size")).toBeNull();
-  });
+    const { contextWindow } = await model.toProviderConfig();
 
-  it("should prefer --ctx-size over --fit-ctx when loaded", async () => {
-    // First call: getStatus() -> fetchModelProps
-    mockRpc.mockResolvedValueOnce({ is_sleeping: false });
-    // Second call: super.getContextSize() -> fetchModels with meta.n_ctx
-    mockRpc.mockResolvedValueOnce({
-      data: [
-        {
-          id: "test-model",
-          meta: { n_ctx: 4096 },
-        },
-      ],
-    });
+    expect(contextWindow).toBe(FALLBACK_CTX);
+  });
 
+  it("should fall back to FALLBACK_CTX when the argument value is not a valid number", async () => {
+    mockUnloaded();
     const model = new RouterModel(
       createModel({
         status: {
-          value: "loaded",
-          args: ["--model", "gguf", "--ctx-size", "4096", "--fit-ctx", "8192"],
+          value: "unloaded",
+          args: ["--model", "gguf", "--ctx-size", "not-a-number"],
           preset: "default",
         },
       }),
       createMockServer(),
     );
 
-    const ctxSize = await model.getContextSize();
-    expect(ctxSize).toBe(4096);
+    const { contextWindow } = await model.toProviderConfig();
+
+    expect(contextWindow).toBe(FALLBACK_CTX);
   });
 
-  it("should return n_ctx from meta when loaded without context size args", async () => {
-    // First call: getStatus() -> fetchModelProps
-    mockRpc.mockResolvedValueOnce({ is_sleeping: false });
-    // Second call: super.getContextSize() -> fetchModels with meta.n_ctx
+  it("should return n_ctx from meta when loaded", async () => {
+    mockRpc.mockResolvedValueOnce({ modalities: { vision: false } }); // capabilities: /props
+    mockRpc.mockResolvedValueOnce({ is_sleeping: false }); // status: /props
+    // super.getContextSize() -> fetchModels with meta.n_ctx
     mockRpc.mockResolvedValueOnce({
       data: [
         {
@@ -151,30 +158,22 @@ describe("RouterModel context size extraction", () => {
       ],
     });
 
-    const model = new RouterModel(
-      createModel({
-        status: {
-          value: "loaded",
-          args: ["--model", "gguf"],
-          preset: "default",
-        },
-      }),
-      createMockServer(),
-    );
+    const model = new RouterModel(createModel(), createMockServer());
+
+    const { contextWindow } = await model.toProviderConfig();
 
-    const ctxSize = await model.getContextSize();
-    expect(ctxSize).toBe(4096);
+    expect(contextWindow).toBe(4096);
   });
 });
 
-describe("RouterModel capabilities detection", () => {
+describe("RouterModel capabilities detection (via toProviderConfig)", () => {
   it("should detect image capability when modalities.vision is true", async () => {
     mockRpc.mockResolvedValueOnce({ modalities: { vision: true } });
 
     const model = new RouterModel(createModel(), createMockServer());
-    const capabilities = await model.getCapabilities();
+    const { input } = await model.toProviderConfig();
 
-    expect(capabilities).toEqual(["text", "image"]);
+    expect(input).toEqual(["text", "image"]);
     expect(mockRpc).toHaveBeenCalledWith(
       "/props?model=test-model&autoload=false",
     );
@@ -187,9 +186,9 @@ describe("RouterModel capabilities detection", () => {
     mockRpc.mockResolvedValueOnce({ data: [] });
 
     const model = new RouterModel(createModel(), createMockServer());
-    const capabilities = await model.getCapabilities();
+    const { input } = await model.toProviderConfig();
 
-    expect(capabilities).toEqual(["text"]);
+    expect(input).toEqual(["text"]);
   });
 
   it("should detect text-only capability when only text in input_modalities", async () => {
@@ -215,9 +214,9 @@ describe("RouterModel capabilities detection", () => {
     });
 
     const model = new RouterModel(createModel(), createMockServer());
-    const capabilities = await model.getCapabilities();
+    const { input } = await model.toProviderConfig();
 
-    expect(capabilities).toEqual(["text"]);
+    expect(input).toEqual(["text"]);
   });
 
   it("should return text when model not found in /models response", async () => {
@@ -239,9 +238,9 @@ describe("RouterModel capabilities detection", () => {
     });
 
     const model = new RouterModel(createModel(), createMockServer());
-    const capabilities = await model.getCapabilities();
+    const { input } = await model.toProviderConfig();
 
-    expect(capabilities).toEqual(["text"]);
+    expect(input).toEqual(["text"]);
   });
 });
 

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({
@@ -87,18 +107,6 @@ describe("Server fetchModelProps", () => {
   });
 });
 
-describe("Server fetchServerHealth", () => {
-  it("should call the /health endpoint", async () => {
-    mockRpc.mockResolvedValueOnce({ status: "ok" });
-
-    const server = createMockServer();
-    const result = await server.fetchServerHealth();
-
-    expect(result).toEqual({ status: "ok" });
-    expect(mockRpc).toHaveBeenCalledWith("/health");
-  });
-});
-
 describe("Server fetchServerProps", () => {
   it("should call the /props endpoint without model", async () => {
     mockRpc.mockResolvedValueOnce({
@@ -195,8 +203,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 +223,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 +234,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",

package/tests/settings.test.ts

@@ -1065,18 +1065,20 @@ describe("Server with overrides", () => {
       },
     });
 
-    expect(server.getOverrides()).toEqual({
-      "model-a": { cost: { input: 0.2, output: 0.6 } },
-      "model-b": { cost: { input: 0.1, output: 0.3, cacheRead: 0.01 } },
+    expect(server.findOverrideForModel("model-a")).toEqual({
+      cost: { input: 0.2, output: 0.6 },
+    });
+    expect(server.findOverrideForModel("model-b")).toEqual({
+      cost: { input: 0.1, output: 0.3, cacheRead: 0.01 },
     });
   });
 
-  it("should return empty object when no overrides are provided", () => {
+  it("should return undefined for findOverrideForModel when no overrides are provided", () => {
     const server = new Server(settings, {
       baseUrl: "http://127.0.0.1:8080",
     });
 
-    expect(server.getOverrides()).toEqual({});
+    expect(server.findOverrideForModel("any-model")).toBeUndefined();
   });
 });
 
@@ -1118,10 +1120,10 @@ describe("resolveServers passes overrides", () => {
     const result = await settings.resolveServers();
 
     expect(result).toHaveLength(2);
-    expect(result[0].getOverrides()).toEqual({
-      "model-x": { cost: { input: 0.5, output: 1.0 } },
+    expect(result[0].findOverrideForModel("model-x")).toEqual({
+      cost: { input: 0.5, output: 1.0 },
     });
-    expect(result[1].getOverrides()).toEqual({});
+    expect(result[1].findOverrideForModel("any-model")).toBeUndefined();
   });
 });
 

package/tests/singleModel.test.ts

@@ -29,23 +29,23 @@ describe("SingleModel mode", () => {
   });
 });
 
-describe("SingleModel capabilities", () => {
+describe("SingleModel capabilities (via toProviderConfig)", () => {
   it("should detect image capability when multimodal is in capabilities", async () => {
     mockRpc.mockResolvedValueOnce({ modalities: { vision: true } });
 
     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 } });
 
     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 the models endpoint when auth fails", async () => {
@@ -59,9 +59,9 @@ describe("SingleModel capabilities", () => {
       }); // /v1/models retry in SingleModel's catch
 
     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 fall back to text-only when the models endpoint reports no multimodal", async () => {
@@ -75,9 +75,9 @@ describe("SingleModel capabilities", () => {
       }); // /v1/models retry in SingleModel's catch
 
     const model = createModel();
-    const capabilities = await model.getCapabilities();
+    const { input } = await model.toProviderConfig();
 
-    expect(capabilities).toEqual(["text"]);
+    expect(input).toEqual(["text"]);
   });
 });
 
@@ -104,16 +104,16 @@ describe("SingleModel getStatus", () => {
   });
 });
 
-describe("SingleModel getContextSize", () => {
+describe("SingleModel context size (via toProviderConfig)", () => {
   it("should return n_ctx from /v1/models endpoint meta", async () => {
     mockRpc.mockResolvedValue({
       data: [{ id: "test", meta: { n_ctx: 8192 } }],
     });
 
     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");
   });
 });

package/tests/sseManager.test.ts

@@ -16,29 +16,15 @@ const createManager = (
       pollingTimeout,
       serverTimeout,
     }),
-    "",
   );
 
-describe("SSEManager timeouts", async () => {
-  it("should expose the timeouts of its server", async () => {
-    const manager = createManager(5678, 1234);
-
-    expect(await manager.getPollingTimeout()).toBe(5678);
-    expect(await manager.getServerTimeout()).toBe(1234);
-  });
-});
-
 describe("SSEManager subscribeToStatus", () => {
   it("should reject after the server's pollingTimeout, not the constant", async () => {
     vi.useFakeTimers();
+    // Never-resolving fetch: the connection stays open but no events arrive
     vi.stubGlobal(
-      "EventSource",
-      class StubEventSource {
-        onopen = null;
-        onerror = null;
-        onmessage = null;
-        close() {}
-      },
+      "fetch",
+      vi.fn(async () => new Promise<Response>(() => {})),
     );
 
     try {
@@ -60,14 +46,10 @@ describe("SSEManager subscribeToStatus", () => {
 
   it("should resolve when a terminal status arrives before the timeout", async () => {
     vi.useFakeTimers();
+    // Never-resolving fetch: events are dispatched manually below
     vi.stubGlobal(
-      "EventSource",
-      class StubEventSource {
-        onopen = null;
-        onerror = null;
-        onmessage = null;
-        close() {}
-      },
+      "fetch",
+      vi.fn(async () => new Promise<Response>(() => {})),
     );
 
     try {