pi-llama-cpp 0.5.0 → 0.6.0

package/tests/mocks.ts

@@ -0,0 +1,97 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { vi } from "vitest";
+import { Mode } from "../src/enums/mode";
+import { Status } from "../src/enums/status";
+import { BaseModel } from "../src/models/baseModel";
+import { Server } from "../src/server";
+
+/** Shared mock RPC — each test configures it */
+export const mockRpc = vi.fn();
+
+/** Default mock server that assumes everything works */
+export const createMockServer = (
+  overrides: Partial<Server & { apiKey?: string }> = {},
+): Server => {
+  const models: BaseModel[] = [];
+  const server: Partial<Server> = {
+    baseUrl: "http://127.0.0.1:8080",
+    models,
+    getApiKey: () => Promise.resolve(overrides.apiKey ?? ""),
+    fetchModels: () => mockRpc("/v1/models"),
+    fetchModelProps: (modelId: string) =>
+      mockRpc(`/props?model=${modelId}&autoload=false`),
+    fetchServerHealth: () => mockRpc("/health"),
+    fetchServerProps: () => mockRpc("/props?autoload=false"),
+    postRequest: (resource: "load" | "unload", model: string) =>
+      mockRpc(`/models/${resource}`, { model }),
+    isReady: async () => {
+      try {
+        const r = await mockRpc("/health");
+        return r.status === "ok";
+      } catch {
+        return false;
+      }
+    },
+    initialize: async () => {
+      const { data } = (await mockRpc("/v1/models")) as {
+        data: BaseModel[];
+      };
+      models.length = 0;
+      models.push(...(data ?? []));
+    },
+    ...overrides,
+  };
+  return server as Server;
+};
+
+/** Helper to create a mock BaseModel */
+export const createMockModel = (
+  name: string,
+  overrides: Partial<BaseModel> = {},
+): BaseModel =>
+  ({
+    name,
+    id: name,
+    mode: Mode.ROUTER,
+    serverUrl: "http://127.0.0.1:8080",
+    capabilities: ["text"] as ["text"],
+    getStatus: vi.fn().mockResolvedValue(Status.LOADED),
+    getContextSize: vi.fn().mockResolvedValue(4096),
+    getInfo: vi.fn().mockResolvedValue(`Model: ${name}\nID: ${name}`),
+    load: vi.fn().mockResolvedValue(undefined),
+    unload: vi.fn().mockResolvedValue(undefined),
+    toProviderConfig: vi.fn().mockResolvedValue({}),
+    getLabel: vi.fn().mockResolvedValue(name),
+    ...overrides,
+  }) as unknown as BaseModel;
+
+/** Create a mock extension context */
+export const createMockCtx = (
+  selectFn: (prompt: string, options: string[]) => string | null,
+) => ({
+  cwd: "/tmp/test",
+  ui: {
+    select: vi.fn(selectFn),
+    notify: vi.fn(),
+    theme: {
+      fg: (color: string, text: string) => text,
+    },
+  },
+  modelRegistry: {
+    find: vi.fn().mockReturnValue({ id: "test-model-id" }),
+  },
+});
+
+/** Create a mock Pi instance */
+export const createMockPi = () => ({
+  setModel: vi.fn(),
+  registerProvider: vi.fn(),
+});
+
+/** Create a mock Pi context for EventManager */
+export const createMockPiContext = (notifyFn: ReturnType<typeof vi.fn>) =>
+  ({
+    ui: {
+      notify: notifyFn,
+    },
+  }) as any as ExtensionContext;

package/tests/resolver.test.ts

@@ -2,156 +2,215 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
   API_KEY_PLACEHOLDER,
   DEFAULT_LLAMA_SERVER_URL,
-  PROVIDER_ID,
 } from "../src/constants";
 
+// Mock getAgentDir before importing resolver
+vi.mock("@earendil-works/pi-coding-agent", () => ({
+  getAgentDir: vi.fn().mockReturnValue("/fake/agent/dir"),
+}));
+
+vi.mock("node:fs/promises", () => ({
+  access: vi.fn(),
+  constants: { F_OK: 0 },
+  readFile: vi.fn(),
+}));
+
+// Import mocked modules
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { access, readFile } from "node:fs/promises";
+import { ConfigResolver } from "../src/resolver";
+
 describe("URL resolution fallback chain", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.resetModules();
-  });
+  const mockAccess = vi.mocked(access);
+  const mockReadFile = vi.mocked(readFile);
+  const mockGetAgentDir = vi.mocked(getAgentDir);
 
   afterEach(() => {
     delete process.env.LLAMA_SERVER_URL;
+    vi.resetModules();
   });
 
-  it("should return default URL when no config is found", async () => {
-    vi.doMock("node:fs/promises", () => ({
-      access: vi.fn().mockRejectedValue(new Error("ENOENT")),
-      constants: { F_OK: 0 },
-      readFile: vi.fn().mockResolvedValue(""),
-    }));
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetAgentDir.mockReturnValue("/fake/agent/dir");
+    // Default: no files exist
+    mockAccess.mockRejectedValue(new Error("ENOENT"));
+    mockReadFile.mockResolvedValue("");
+  });
 
-    const { resolveUrl } = await import("../src/tools/resolver");
-    const result = await resolveUrl("/tmp/test-project");
+  it("should return default URL when no config is found", async () => {
+    const resolver = new ConfigResolver();
+    const result = await resolver.resolveUrls("/tmp/test-project");
 
-    expect(result).toBe(DEFAULT_LLAMA_SERVER_URL);
+    expect(result).toEqual([DEFAULT_LLAMA_SERVER_URL]);
   });
 
   it("should prioritize project config over env variable", async () => {
-    vi.doMock("node:fs/promises", () => ({
-      access: vi.fn().mockImplementation(async (path: string) => {
-        if (path.includes("llama-server.json")) return undefined;
-        throw new Error("ENOENT");
-      }),
-      constants: { F_OK: 0 },
-      readFile: vi
-        .fn()
-        .mockResolvedValue(JSON.stringify({ url: "http://localhost:9999" })),
-    }));
+    mockAccess.mockImplementation(async (_path: unknown) => {
+      if (typeof _path === "string" && _path.includes("llama-server.json"))
+        return undefined;
+      throw new Error("ENOENT");
+    });
+    mockReadFile.mockResolvedValue(
+      JSON.stringify({ url: "http://localhost:9999" }),
+    );
 
     process.env.LLAMA_SERVER_URL = "http://env-url:8080";
 
-    const { resolveUrl } = await import("../src/tools/resolver");
-    const result = await resolveUrl("/tmp/test-project");
+    const resolver = new ConfigResolver();
+    const result = await resolver.resolveUrls("/tmp/test-project");
 
-    expect(result).toBe("http://localhost:9999");
+    expect(result).toEqual(["http://localhost:9999"]);
   });
 
   it("should use env variable when no project config exists", async () => {
-    vi.doMock("node:fs/promises", () => ({
-      access: vi.fn().mockRejectedValue(new Error("ENOENT")),
-      constants: { F_OK: 0 },
-      readFile: vi.fn().mockResolvedValue(""),
-    }));
-
     process.env.LLAMA_SERVER_URL = "http://env-url:8080";
 
-    const { resolveUrl } = await import("../src/tools/resolver");
-    const result = await resolveUrl("/tmp/test-project");
+    const resolver = new ConfigResolver();
+    const result = await resolver.resolveUrls("/tmp/test-project");
 
-    expect(result).toBe("http://env-url:8080");
+    expect(result).toEqual(["http://env-url:8080"]);
   });
 
   it("should use global settings when no project config or env exists", async () => {
-    vi.doMock("node:fs/promises", () => ({
-      access: vi.fn().mockImplementation(async (path: string) => {
-        if (path.includes("settings.json")) return undefined;
-        throw new Error("ENOENT");
-      }),
-      constants: { F_OK: 0 },
-      readFile: vi
-        .fn()
-        .mockResolvedValue(
-          JSON.stringify({ llamaServerUrl: "http://global:8080" }),
-        ),
-    }));
-
-    const { resolveUrl } = await import("../src/tools/resolver");
-    const result = await resolveUrl("/tmp/test-project");
-
-    expect(result).toBe("http://global:8080");
+    mockAccess.mockImplementation(async (_path: unknown) => {
+      if (typeof _path === "string" && _path.includes("settings.json"))
+        return undefined;
+      throw new Error("ENOENT");
+    });
+    mockReadFile.mockResolvedValue(
+      JSON.stringify({ llamaServerUrl: "http://global:8080" }),
+    );
+
+    const resolver = new ConfigResolver();
+    const result = await resolver.resolveUrls("/tmp/test-project");
+
+    expect(result).toEqual(["http://global:8080"]);
   });
 
   it("should strip trailing slashes from resolved URL", async () => {
-    vi.doMock("node:fs/promises", () => ({
-      access: vi.fn().mockImplementation(async (path: string) => {
-        if (path.includes("llama-server.json")) return undefined;
-        throw new Error("ENOENT");
-      }),
-      constants: { F_OK: 0 },
-      readFile: vi
-        .fn()
-        .mockResolvedValue(JSON.stringify({ url: "http://localhost:8080/" })),
-    }));
+    mockAccess.mockImplementation(async (_path: unknown) => {
+      if (typeof _path === "string" && _path.includes("llama-server.json"))
+        return undefined;
+      throw new Error("ENOENT");
+    });
+    mockReadFile.mockResolvedValue(
+      JSON.stringify({ url: "http://localhost:8080/" }),
+    );
+
+    const resolver = new ConfigResolver();
+    const result = await resolver.resolveUrls("/tmp/test-project");
+
+    expect(result).toEqual(["http://localhost:8080"]);
+  });
 
-    const { resolveUrl } = await import("../src/tools/resolver");
-    const result = await resolveUrl("/tmp/test-project");
+  it("should cache the resolved URL on subsequent calls", async () => {
+    mockAccess.mockImplementation(async (_path: unknown) => {
+      if (typeof _path === "string" && _path.includes("llama-server.json"))
+        return undefined;
+      throw new Error("ENOENT");
+    });
+    mockReadFile.mockResolvedValue(
+      JSON.stringify({ url: "http://first:8080" }),
+    );
+
+    const resolver = new ConfigResolver();
+    const result1 = await resolver.resolveUrls("/tmp/project1");
+    const result2 = await resolver.resolveUrls("/tmp/project2");
+
+    expect(result1).toEqual(["http://first:8080"]);
+    expect(result2).toEqual(["http://first:8080"]);
+  });
+
+  it("should handle multiple URLs separated by semicolons", async () => {
+    mockAccess.mockImplementation(async (_path: unknown) => {
+      if (typeof _path === "string" && _path.includes("llama-server.json"))
+        return undefined;
+      throw new Error("ENOENT");
+    });
+    mockReadFile.mockResolvedValue(
+      JSON.stringify({ url: "http://first:8080;http://second:9090/" }),
+    );
+
+    const resolver = new ConfigResolver();
+    const result = await resolver.resolveUrls("/tmp/test-project");
 
-    expect(result).toBe("http://localhost:8080");
+    expect(result).toEqual(["http://first:8080", "http://second:9090"]);
   });
 });
 
 describe("API key resolution", () => {
+  const mockAccess = vi.mocked(access);
+  const mockReadFile = vi.mocked(readFile);
+  const mockGetAgentDir = vi.mocked(getAgentDir);
+
+  afterEach(() => {
+    vi.resetModules();
+  });
+
   beforeEach(() => {
     vi.clearAllMocks();
-    vi.resetModules();
+    mockGetAgentDir.mockReturnValue("/fake/agent/dir");
+    mockAccess.mockRejectedValue(new Error("ENOENT"));
+    mockReadFile.mockResolvedValue("");
   });
 
   it("should return placeholder when auth file does not exist", async () => {
-    vi.doMock("node:fs/promises", () => ({
-      access: vi.fn().mockRejectedValue(new Error("ENOENT")),
-      constants: { F_OK: 0 },
-      readFile: vi.fn().mockResolvedValue(""),
-    }));
+    const resolver = new ConfigResolver();
+    const result = await resolver.resolveApiKey(
+      "llama-server=http://127.0.0.1:8080",
+    );
 
-    const { resolveApiKey } = await import("../src/tools/resolver");
-    const result = await resolveApiKey();
-
-    expect(result).toBe(API_KEY_PLACEHOLDER);
+    expect(result).toEqual(API_KEY_PLACEHOLDER);
   });
 
   it("should return placeholder when provider key is missing", async () => {
-    vi.doMock("node:fs/promises", () => ({
-      access: vi.fn().mockResolvedValue(undefined),
-      constants: { F_OK: 0 },
-      readFile: vi
-        .fn()
-        .mockResolvedValue(
-          JSON.stringify({ "other-provider": { key: "other-key" } }),
-        ),
-    }));
-
-    const { resolveApiKey } = await import("../src/tools/resolver");
-    const result = await resolveApiKey();
-
-    expect(result).toBe(API_KEY_PLACEHOLDER);
+    mockAccess.mockResolvedValue(undefined);
+    mockReadFile.mockResolvedValue(
+      JSON.stringify({ "other-provider": { key: "other-key" } }),
+    );
+
+    const resolver = new ConfigResolver();
+    const result = await resolver.resolveApiKey(
+      "llama-server=http://127.0.0.1:8080",
+    );
+
+    expect(result).toEqual(API_KEY_PLACEHOLDER);
   });
 
   it("should return the provider key when present", async () => {
-    vi.doMock("node:fs/promises", () => ({
-      access: vi.fn().mockResolvedValue(undefined),
-      constants: { F_OK: 0 },
-      readFile: vi
-        .fn()
-        .mockResolvedValue(
-          JSON.stringify({ [PROVIDER_ID]: { key: "test-api-key" } }),
-        ),
-    }));
-
-    const { resolveApiKey } = await import("../src/tools/resolver");
-    const result = await resolveApiKey();
-
-    expect(result).toBe("test-api-key");
+    mockAccess.mockResolvedValue(undefined);
+    mockReadFile.mockResolvedValue(
+      JSON.stringify({
+        "llama-server=http://127.0.0.1:8080": { key: "test-api-key" },
+      }),
+    );
+
+    const resolver = new ConfigResolver();
+    const result = await resolver.resolveApiKey(
+      "llama-server=http://127.0.0.1:8080",
+    );
+
+    expect(result).toEqual("test-api-key");
+  });
+
+  it("should cache the auth file and reuse the key", async () => {
+    mockAccess.mockResolvedValue(undefined);
+    mockReadFile.mockResolvedValue(
+      JSON.stringify({
+        "llama-server=http://127.0.0.1:8080": { key: "cached-key" },
+      }),
+    );
+
+    const resolver = new ConfigResolver();
+    const result1 = await resolver.resolveApiKey(
+      "llama-server=http://127.0.0.1:8080",
+    );
+    const result2 = await resolver.resolveApiKey(
+      "llama-server=http://127.0.0.1:8080",
+    );
+
+    expect(result1).toBe("cached-key");
+    expect(result2).toBe("cached-key");
   });
 });

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);
   });
 });