pi-llama-cpp 0.13.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

@@ -107,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({

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 {