pi-llama-cpp 0.13.0 → 0.15.0

package/tests/{events.test.ts → events/events.test.ts}

@@ -1,10 +1,10 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import { THINKING_BUDGETS } from "../src/constants";
-import { Status } from "../src/enums/status";
-import { EventManager } from "../src/managers/events";
-import { ServerManager } from "../src/managers/server";
-import type { Server } from "../src/server";
-import { createMockModel, createMockServer, makeSettingsStub } from "./mocks";
+import { THINKING_BUDGETS } from "../../src/constants";
+import { Status } from "../../src/enums/status";
+import { EventManager } from "../../src/managers/events";
+import { ServerManager } from "../../src/managers/server";
+import type { Server } from "../../src/server";
+import { createMockModel, createMockServer, makeSettingsStub } from "../mocks";
 
 /**
  * Injected settings stub (EventManager and — in the live-list test — the

package/tests/mocks.ts

@@ -7,6 +7,7 @@ import {
   POLLING_TIMEOUT,
   REACT_TO_MODEL_SELECT,
   SERVER_TIMEOUT,
+  SHOW_SERVER_URLS,
   SORT_BY,
   THINKING_BUDGETS,
 } from "../src/constants";
@@ -40,6 +41,7 @@ export const makeSettingsStub = (
     })),
     resolveServers: vi.fn(async () => []),
     resolveSortBy: vi.fn(async () => SORT_BY),
+    resolveShowServerUrls: vi.fn(async () => SHOW_SERVER_URLS),
     resolveApiKey: vi.fn(() => API_KEY_PLACEHOLDER),
     resolveReactToModelSelect: vi.fn(async () => REACT_TO_MODEL_SELECT),
     resolveAutoloadOnMessage: vi.fn(async () => AUTOLOAD_ON_MESSAGE),

package/tests/models/legacyModel.test.ts

@@ -0,0 +1,103 @@
+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";
+import { createMockServer, mockRpc } from "../mocks";
+
+beforeEach(() => {
+  mockRpc.mockReset();
+});
+
+const createModel = (extra: Partial<DataProperty> = {}): LegacyModel =>
+  new LegacyModel(
+    {
+      id: "test",
+      tags: [],
+      object: "model",
+      owned_by: "test",
+      created: Date.now(),
+      ...extra,
+    },
+    createMockServer(),
+  );
+
+describe("LegacyModel mode", () => {
+  it("should always return LEGACY mode", () => {
+    const model = createModel();
+    expect(model.mode).toBe(Mode.LEGACY);
+  });
+});
+
+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 { input } = await model.toProviderConfig();
+
+    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 { input } = await model.toProviderConfig();
+
+    expect(input).toEqual(["text"]);
+  });
+
+  it("should fall back to text-only when auth fails", async () => {
+    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 { input } = await model.toProviderConfig();
+
+    expect(input).toEqual(["text"]);
+  });
+});
+
+describe("LegacyModel context size (via toProviderConfig)", () => {
+  it("should use max_model_len when it is non-zero", async () => {
+    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 { contextWindow } = await model.toProviderConfig();
+
+    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({ modalities: { vision: false } }); // capabilities: /props
+    mockRpc.mockResolvedValueOnce({ n_ctx: 4096 }); // /props
+    mockRpc.mockResolvedValueOnce({ data: [{ max_model_len: 0 }] }); // /v1/models
+
+    const model = createModel();
+    const { contextWindow } = await model.toProviderConfig();
+
+    expect(contextWindow).toBe(4096);
+  });
+
+  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 { contextWindow } = await model.toProviderConfig();
+
+    expect(contextWindow).toBe(FALLBACK_CTX);
+  });
+});

package/tests/{routerModel.test.ts → models/routerModel.test.ts}

@@ -1,8 +1,9 @@
 import { beforeEach, describe, expect, it } from "vitest";
-import { Mode } from "../src/enums/mode";
-import { DataProperty } from "../src/interfaces/endpoints/models";
-import { RouterModel } from "../src/models/routerModel";
-import { createMockServer, mockRpc } from "./mocks";
+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";
+import { createMockServer, mockRpc } from "../mocks";
 
 // Helper to create a mock DataProperty
 const createModel = (overrides: Partial<DataProperty> = {}): DataProperty => ({
@@ -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/{singleModel.test.ts → models/singleModel.test.ts}

@@ -1,9 +1,9 @@
 import { beforeEach, describe, expect, it } from "vitest";
-import { Mode } from "../src/enums/mode";
-import { Status } from "../src/enums/status";
-import { DataProperty } from "../src/interfaces/endpoints/models";
-import { SingleModel } from "../src/models/singleModel";
-import { createMockServer, mockRpc } from "./mocks";
+import { Mode } from "../../src/enums/mode";
+import { Status } from "../../src/enums/status";
+import { DataProperty } from "../../src/interfaces/endpoints/models";
+import { SingleModel } from "../../src/models/singleModel";
+import { createMockServer, mockRpc } from "../mocks";
 
 beforeEach(() => {
   mockRpc.mockReset();
@@ -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/{health.test.ts → server/health.test.ts}

@@ -1,6 +1,6 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { ServerStatus } from "../src/enums/serverStatus";
-import { checkServerHealth } from "../src/utils/health";
+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,

package/tests/{server.test.ts → server/server.test.ts}

@@ -1,9 +1,9 @@
 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";
-import { Server } from "../src/server";
-import { createMockServer, makeSettingsStub, mockRpc } from "./mocks";
+import { POLLING_TIMEOUT, SERVER_TIMEOUT } from "../../src/constants";
+import { ServerStatus } from "../../src/enums/serverStatus";
+import type { LlamaSettingsManager } from "../../src/managers/settings";
+import { Server } from "../../src/server";
+import { createMockServer, makeSettingsStub, mockRpc } from "../mocks";
 
 // Injected into every real Server below; fresh per test so per-case
 // overrides never leak. The Server constructor resolves the API key eagerly
@@ -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/{serverManager.test.ts → server/serverManager.test.ts}

@@ -1,13 +1,13 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import { ServerManager } from "../src/managers/server";
-import { BaseModel } from "../src/models/baseModel";
-import { Server } from "../src/server";
+import { ServerManager } from "../../src/managers/server";
+import { BaseModel } from "../../src/models/baseModel";
+import { Server } from "../../src/server";
 import {
   createMockModel,
   createMockServer,
   makeSettingsStub,
   mockRpc,
-} from "./mocks";
+} from "../mocks";
 
 // Injected settings stub — the single instance passed to ServerManager and
 // to every real `new Server(...)` construction below (Server's eager