pi-llama-cpp 0.5.1 → 0.7.0

package/tests/routerModel.test.ts

@@ -1,16 +1,8 @@
-import { describe, expect, it, vi } from "vitest";
+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";
-
-// Mock the retriever module before importing anything that depends on it
-const mockRpc = vi.fn();
-
-vi.mock("../src/tools/retriever", () => ({
-  rpc: (...args: unknown[]) => mockRpc(...args),
-  isServerReady: vi.fn(),
-  listModels: vi.fn(),
-}));
+import { createMockServer, mockRpc } from "./mocks";
 
 // Helper to create a mock DataProperty
 const createModel = (overrides: Partial<DataProperty> = {}): DataProperty => ({
@@ -24,6 +16,10 @@ const createModel = (overrides: Partial<DataProperty> = {}): DataProperty => ({
   ...overrides,
 });
 
+beforeEach(() => {
+  mockRpc.mockClear();
+});
+
 describe("RouterModel context size extraction", () => {
   it("should extract --ctx-size value", () => {
     const model = new RouterModel(
@@ -41,6 +37,7 @@ describe("RouterModel context size extraction", () => {
           preset: "default",
         },
       }),
+      createMockServer(),
     );
 
     // Access the private method via any
@@ -57,6 +54,7 @@ describe("RouterModel context size extraction", () => {
           preset: "default",
         },
       }),
+      createMockServer(),
     );
 
     const extractFrom = (model as any).extractFrom.bind(model);
@@ -72,6 +70,7 @@ describe("RouterModel context size extraction", () => {
           preset: "default",
         },
       }),
+      createMockServer(),
     );
 
     const extractFrom = (model as any).extractFrom.bind(model);
@@ -88,6 +87,7 @@ describe("RouterModel context size extraction", () => {
           preset: "default",
         },
       }),
+      createMockServer(),
     );
 
     const extractFrom = (model as any).extractFrom.bind(model);
@@ -103,6 +103,7 @@ describe("RouterModel context size extraction", () => {
           preset: "default",
         },
       }),
+      createMockServer(),
     );
 
     const extractFrom = (model as any).extractFrom.bind(model);
@@ -110,27 +111,9 @@ describe("RouterModel context size extraction", () => {
   });
 
   it("should prefer --ctx-size over --fit-ctx when loaded", async () => {
-    // First call: getStatus() -> /models
-    mockRpc.mockResolvedValueOnce({
-      data: [
-        {
-          id: "test-model",
-          status: {
-            value: "loaded",
-            args: [
-              "--model",
-              "gguf",
-              "--ctx-size",
-              "4096",
-              "--fit-ctx",
-              "8192",
-            ],
-            preset: "default",
-          },
-        },
-      ],
-    });
-    // Second call: super.getContextSize() -> /models with meta.n_ctx
+    // First call: getStatus() -> fetchModelProps
+    mockRpc.mockResolvedValueOnce({ is_sleeping: false });
+    // Second call: super.getContextSize() -> fetchModels with meta.n_ctx
     mockRpc.mockResolvedValueOnce({
       data: [
         {
@@ -148,6 +131,7 @@ describe("RouterModel context size extraction", () => {
           preset: "default",
         },
       }),
+      createMockServer(),
     );
 
     const ctxSize = await model.getContextSize();
@@ -155,20 +139,9 @@ describe("RouterModel context size extraction", () => {
   });
 
   it("should return n_ctx from meta when loaded without context size args", async () => {
-    // First call: getStatus() -> /models
-    mockRpc.mockResolvedValueOnce({
-      data: [
-        {
-          id: "test-model",
-          status: {
-            value: "loaded",
-            args: ["--model", "gguf"],
-            preset: "default",
-          },
-        },
-      ],
-    });
-    // Second call: super.getContextSize() -> /models with meta.n_ctx
+    // First call: getStatus() -> fetchModelProps
+    mockRpc.mockResolvedValueOnce({ is_sleeping: false });
+    // Second call: super.getContextSize() -> fetchModels with meta.n_ctx
     mockRpc.mockResolvedValueOnce({
       data: [
         {
@@ -186,6 +159,7 @@ describe("RouterModel context size extraction", () => {
           preset: "default",
         },
       }),
+      createMockServer(),
     );
 
     const ctxSize = await model.getContextSize();
@@ -194,33 +168,34 @@ describe("RouterModel context size extraction", () => {
 });
 
 describe("RouterModel capabilities detection", () => {
-  it("should detect image capability from architecture.input_modalities", async () => {
-    mockRpc.mockResolvedValueOnce({
-      data: [
-        {
-          id: "test-model",
-          status: {
-            value: "loaded",
-            args: [],
-            preset: "default",
-            failed: false,
-          },
-          architecture: {
-            input_modalities: ["text", "image"],
-            output_modalities: ["text"],
-          },
-        },
-      ],
-    });
+  it("should detect image capability when modalities.vision is true", async () => {
+    mockRpc.mockResolvedValueOnce({ modalities: { vision: true } });
 
-    const model = new RouterModel(createModel());
+    const model = new RouterModel(createModel(), createMockServer());
     const capabilities = await model.getCapabilities();
 
     expect(capabilities).toEqual(["text", "image"]);
-    expect(mockRpc).toHaveBeenCalledWith("/models");
+    expect(mockRpc).toHaveBeenCalledWith(
+      "/props?model=test-model&autoload=false",
+    );
+  });
+
+  it("should return text-only when fetchModelProps fails", async () => {
+    // First call (fetchModelProps) throws to trigger fallback
+    mockRpc.mockRejectedValueOnce(new Error("props not available"));
+    // Second call (fetchModels) returns empty data so model is not found
+    mockRpc.mockResolvedValueOnce({ data: [] });
+
+    const model = new RouterModel(createModel(), createMockServer());
+    const capabilities = await model.getCapabilities();
+
+    expect(capabilities).toEqual(["text"]);
   });
 
   it("should detect text-only capability when only text in input_modalities", async () => {
+    // First call (fetchModelProps) throws to trigger fallback
+    mockRpc.mockRejectedValueOnce(new Error("props not available"));
+    // Second call (fetchModels) returns the data
     mockRpc.mockResolvedValueOnce({
       data: [
         {
@@ -239,13 +214,16 @@ describe("RouterModel capabilities detection", () => {
       ],
     });
 
-    const model = new RouterModel(createModel());
+    const model = new RouterModel(createModel(), createMockServer());
     const capabilities = await model.getCapabilities();
 
     expect(capabilities).toEqual(["text"]);
   });
 
   it("should return text when model not found in /models response", async () => {
+    // First call (fetchModelProps) throws to trigger fallback
+    mockRpc.mockRejectedValueOnce(new Error("props not available"));
+    // Second call (fetchModels) returns data without matching model
     mockRpc.mockResolvedValueOnce({
       data: [
         {
@@ -260,7 +238,7 @@ describe("RouterModel capabilities detection", () => {
       ],
     });
 
-    const model = new RouterModel(createModel());
+    const model = new RouterModel(createModel(), createMockServer());
     const capabilities = await model.getCapabilities();
 
     expect(capabilities).toEqual(["text"]);
@@ -269,7 +247,7 @@ describe("RouterModel capabilities detection", () => {
 
 describe("RouterModel mode", () => {
   it("should always return ROUTER mode", () => {
-    const model = new RouterModel(createModel());
+    const model = new RouterModel(createModel(), createMockServer());
     expect(model.mode).toBe(Mode.ROUTER);
   });
 });

package/tests/server.test.ts

@@ -0,0 +1,176 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { ServerStatus } from "../src/enums/serverStatus";
+import { Server } from "../src/server";
+import { createMockServer, mockRpc } from "./mocks";
+
+beforeEach(() => {
+  mockRpc.mockClear();
+});
+
+describe("Server providerId", () => {
+  it("should generate a unique provider ID from baseUrl", () => {
+    const server = new Server("http://127.0.0.1:8080");
+    expect(server.providerId).toBe("llama-server=http://127.0.0.1:8080");
+  });
+
+  it("should generate different IDs for different baseUrls", () => {
+    const server1 = new Server("http://127.0.0.1:8080");
+    const server2 = new Server("http://127.0.0.1:8081");
+    expect(server1.providerId).not.toBe(server2.providerId);
+  });
+});
+
+describe("Server providerName", () => {
+  it("should generate a human-readable provider name", () => {
+    const server = new Server("http://127.0.0.1:8080");
+    expect(server.providerName).toBe("Llama.cpp (http://127.0.0.1:8080)");
+  });
+});
+
+describe("Server fetchModels", () => {
+  it("should call the /models endpoint", async () => {
+    mockRpc.mockResolvedValueOnce({
+      data: [{ id: "model1" }],
+      models: [{ id: "model1" }],
+      object: "list",
+    });
+
+    const server = createMockServer();
+    const result = await server.fetchModels();
+
+    expect(result).toEqual({
+      data: [{ id: "model1" }],
+      models: [{ id: "model1" }],
+      object: "list",
+    });
+    expect(mockRpc).toHaveBeenCalledWith("/v1/models");
+  });
+});
+
+describe("Server fetchModelProps", () => {
+  it("should call the /props endpoint with model id", async () => {
+    mockRpc.mockResolvedValueOnce({
+      is_sleeping: false,
+      default_generation_settings: {},
+      total_slots: 1,
+      model_alias: "test",
+      model_path: "/path/to/model.gguf",
+      modalities: { vision: false, audio: false },
+      media_marker: "",
+      endpoint_slots: false,
+      endpoint_props: false,
+      endpoint_metrics: false,
+      webui: false,
+      webui_settings: {},
+      chat_template: "",
+      chat_template_caps: {},
+      bos_token: "",
+      eos_token: "",
+      build_info: "",
+    });
+
+    const server = createMockServer();
+    const result = await server.fetchModelProps("test-model");
+
+    expect(result.is_sleeping).toBe(false);
+    expect(mockRpc).toHaveBeenCalledWith(
+      "/props?model=test-model&autoload=false",
+    );
+  });
+});
+
+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({
+      role: "router",
+      default_generation_settings: {},
+      total_slots: 2,
+      model_alias: "",
+      model_path: "",
+      modalities: { vision: false, audio: false },
+      media_marker: "",
+      endpoint_slots: false,
+      endpoint_props: false,
+      endpoint_metrics: false,
+      webui: false,
+      webui_settings: {},
+      chat_template: "",
+      chat_template_caps: {},
+      bos_token: "",
+      eos_token: "",
+      build_info: "",
+      is_sleeping: false,
+    });
+
+    const server = createMockServer();
+    const result = await server.fetchServerProps();
+
+    expect(result.role).toBe("router");
+    expect(mockRpc).toHaveBeenCalledWith("/props?autoload=false");
+  });
+});
+
+describe("Server postRequest", () => {
+  it("should call /models/load with model in body", async () => {
+    mockRpc.mockResolvedValueOnce({});
+
+    const server = createMockServer();
+    await server.postRequest("load", "test-model");
+
+    expect(mockRpc).toHaveBeenCalledWith("/models/load", {
+      model: "test-model",
+    });
+  });
+
+  it("should call /models/unload with model in body", async () => {
+    mockRpc.mockResolvedValueOnce({});
+
+    const server = createMockServer();
+    await server.postRequest("unload", "test-model");
+
+    expect(mockRpc).toHaveBeenCalledWith("/models/unload", {
+      model: "test-model",
+    });
+  });
+});
+
+describe("Server isReady", () => {
+  it("should return READY when health status is ok", async () => {
+    mockRpc.mockResolvedValueOnce({ status: "ok" });
+
+    const server = createMockServer();
+    const status = await server.isReady(1000);
+
+    expect(status).toBe(ServerStatus.READY);
+  });
+
+  it("should return UNREACHABLE when health check fails", async () => {
+    mockRpc.mockRejectedValueOnce(new Error("connection refused"));
+
+    const server = createMockServer();
+    const status = await server.isReady(1000);
+
+    expect(status).toBe(ServerStatus.UNREACHABLE);
+  });
+
+  it("should return UNREACHABLE when health status is not ok", async () => {
+    mockRpc.mockResolvedValueOnce({ status: "error" });
+
+    const server = createMockServer();
+    const status = await server.isReady(1000);
+
+    expect(status).toBe(ServerStatus.UNREACHABLE);
+  });
+});

package/tests/serverManager.test.ts

@@ -0,0 +1,130 @@
+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 { createMockServer, mockRpc } from "./mocks";
+
+const mockPi = {
+  registerProvider: vi.fn(),
+  registerCommand: vi.fn(),
+  setModel: vi.fn(),
+};
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockRpc.mockImplementation((endpoint: string, fallback?: unknown) => {
+    const defaults: Record<string, unknown> = {
+      "/health": { status: "ok" },
+      "/props?autoload=false": { role: "router" },
+      "/v1/models": { data: [], object: "list" },
+    };
+    return Promise.resolve(defaults[endpoint] ?? fallback ?? {});
+  });
+});
+
+describe("Server", () => {
+  it("should generate provider IDs from URLs", () => {
+    const server1 = new Server("http://127.0.0.1:8080");
+    expect(server1.providerId).toBe("llama-server=http://127.0.0.1:8080");
+    const server2 = new Server("http://10.0.0.5:8080");
+    expect(server2.providerId).toBe("llama-server=http://10.0.0.5:8080");
+    const server3 = new Server("http://127.0.0.1");
+    expect(server3.providerId).toBe("llama-server=http://127.0.0.1");
+    const server4 = new Server("http://127.0.0.1:80");
+    expect(server4.providerId).toBe("llama-server=http://127.0.0.1:80");
+    const server5 = new Server("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("http://127.0.0.1:8080");
+    expect(server1.providerName).toBe("Llama.cpp (http://127.0.0.1:8080)");
+    const server2 = new Server("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 = {
+      name: "test-model",
+      id: "test-model",
+      toProviderConfig: vi.fn().mockResolvedValue({ id: "test-model" }),
+    } as unknown as BaseModel;
+    mockRpc.mockImplementation((endpoint: string, fallback?: unknown) => {
+      if (endpoint === "/v1/models") {
+        return Promise.resolve({ data: [mockModel], object: "list" });
+      }
+      const defaults: Record<string, unknown> = {
+        "/health": { status: "ok" },
+        "/props?autoload=false": { role: "router" },
+      };
+      return Promise.resolve(defaults[endpoint] ?? fallback ?? {});
+    });
+
+    const server1 = createMockServer({
+      baseUrl: "http://127.0.0.1:8080",
+      apiKey: "key-1",
+      providerId: "llama-server=http://127.0.0.1:8080",
+      providerName: "Llama.cpp (http://127.0.0.1:8080)",
+    });
+    const server2 = createMockServer({
+      baseUrl: "http://127.0.0.1:8081",
+      apiKey: "key-2",
+      providerId: "llama-server=http://127.0.0.1:8081",
+      providerName: "Llama.cpp (http://127.0.0.1:8081)",
+    });
+    const manager = new ServerManager([server1, server2] as any);
+
+    await manager.initialize(mockPi as any);
+
+    expect(mockPi.registerProvider).toHaveBeenCalledTimes(2);
+    expect(mockPi.registerProvider).toHaveBeenCalledWith(
+      "llama-server=http://127.0.0.1:8080",
+      {
+        name: "Llama.cpp (http://127.0.0.1:8080)",
+        baseUrl: "http://127.0.0.1:8080",
+        api: "openai-completions",
+        apiKey: "key-1",
+        models: [{ id: "test-model" }],
+      },
+    );
+    expect(mockPi.registerProvider).toHaveBeenCalledWith(
+      "llama-server=http://127.0.0.1:8081",
+      {
+        name: "Llama.cpp (http://127.0.0.1:8081)",
+        baseUrl: "http://127.0.0.1:8081",
+        api: "openai-completions",
+        apiKey: "key-2",
+        models: [{ id: "test-model" }],
+      },
+    );
+  });
+
+  it("should return all models from all servers", () => {
+    const mockModel1 = {
+      name: "model-1",
+      id: "model-1",
+    } as unknown as BaseModel;
+    const mockModel2 = {
+      name: "model-2",
+      id: "model-2",
+    } as unknown as BaseModel;
+    const server1 = createMockServer({
+      baseUrl: "http://127.0.0.1:8080",
+    });
+    const server2 = createMockServer({
+      baseUrl: "http://127.0.0.1:8081",
+    });
+    const manager = new ServerManager([
+      { ...server1, models: [mockModel1] } as any,
+      { ...server2, models: [mockModel2] } as any,
+    ] as any);
+
+    const allModels = manager.getAllModels();
+
+    expect(allModels).toHaveLength(2);
+    expect(allModels[0]).toBe(mockModel1);
+    expect(allModels[1]).toBe(mockModel2);
+  });
+});

package/tests/singleModel.test.ts

@@ -1,29 +1,26 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it } from "vitest";
 import { Mode } from "../src/enums/mode";
 import { Status } from "../src/enums/status";
-import { ModelProperty } from "../src/interfaces/endpoints/models";
+import { DataProperty } from "../src/interfaces/endpoints/models";
 import { SingleModel } from "../src/models/singleModel";
-
-const mockRpc = vi.fn();
-
-vi.mock("../src/tools/retriever", () => ({
-  rpc: (...args: unknown[]) => mockRpc(...args),
-  isServerReady: vi.fn(),
-  listModels: vi.fn(),
-}));
+import { createMockServer, mockRpc } from "./mocks";
 
 beforeEach(() => {
-  mockRpc.mockClear();
+  mockRpc.mockReset();
 });
 
-const createModel = (extra: Partial<ModelProperty> = {}): SingleModel =>
-  new SingleModel({
-    id: "test",
-    tags: [],
-    object: "model",
-    owned_by: "test",
-    created: Date.now(),
-  });
+const createModel = (extra: Partial<DataProperty> = {}): SingleModel =>
+  new SingleModel(
+    {
+      id: "test",
+      tags: [],
+      object: "model",
+      owned_by: "test",
+      created: Date.now(),
+      ...extra,
+    },
+    createMockServer(),
+  );
 
 describe("SingleModel mode", () => {
   it("should always return SINGLE mode", () => {
@@ -34,21 +31,16 @@ describe("SingleModel mode", () => {
 
 describe("SingleModel capabilities", () => {
   it("should detect image capability when multimodal is in capabilities", async () => {
-    mockRpc.mockResolvedValueOnce({
-      models: [{ id: "test", capabilities: ["multimodal"] }],
-    });
+    mockRpc.mockResolvedValueOnce({ modalities: { vision: true } });
 
     const model = createModel();
     const capabilities = await model.getCapabilities();
 
     expect(capabilities).toEqual(["text", "image"]);
-    expect(mockRpc).toHaveBeenCalledWith("/models");
   });
 
   it("should detect text-only capability when multimodal is not in capabilities", async () => {
-    mockRpc.mockResolvedValueOnce({
-      models: [{ id: "test", capabilities: [] }],
-    });
+    mockRpc.mockResolvedValueOnce({ modalities: { vision: false } });
 
     const model = createModel();
     const capabilities = await model.getCapabilities();
@@ -81,8 +73,8 @@ describe("SingleModel getStatus", () => {
 });
 
 describe("SingleModel getContextSize", () => {
-  it("should return n_ctx from /models endpoint meta", async () => {
-    mockRpc.mockResolvedValueOnce({
+  it("should return n_ctx from /v1/models endpoint meta", async () => {
+    mockRpc.mockResolvedValue({
       data: [{ id: "test", meta: { n_ctx: 8192 } }],
     });
 
@@ -90,6 +82,6 @@ describe("SingleModel getContextSize", () => {
     const ctxSize = await model.getContextSize();
 
     expect(ctxSize).toBe(8192);
-    expect(mockRpc).toHaveBeenCalledWith("/models");
+    expect(mockRpc).toHaveBeenCalledWith("/v1/models");
   });
 });