pi-llama-cpp 0.2.2 → 0.2.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-llama-cpp",
-  "version": "0.2.2",
-  "description": "Pi extension for llama.cpp integration. Supports both router and single modes",
+  "version": "0.2.3",
+  "description": "Pi extension for llama.cpp integration. Supports both router and single modes.",
   "keywords": [
     "pi",
     "pi-package",
@@ -23,6 +23,10 @@
       "./src/index.ts"
     ]
   },
+  "scripts": {
+    "test": "vitest",
+    "test:run": "vitest run"
+  },
   "prettier": {
     "plugins": [
       "prettier-plugin-organize-imports"
@@ -33,6 +37,7 @@
   },
   "devDependencies": {
     "@types/node": "^25.6.0",
-    "prettier-plugin-organize-imports": "^4.3.0"
+    "prettier-plugin-organize-imports": "^4.3.0",
+    "vitest": "^4.1.5"
   }
 }

package/src/constants.ts

@@ -13,6 +13,11 @@ export const PROVIDER_NAME = "Llama.cpp";
  */
 export const DEFAULT_LLAMA_SERVER_URL = "http://127.0.0.1:8080";
 
+/**
+ * The placeholder api-key if it couldn't be resolved
+ */
+export const API_KEY_PLACEHOLDER = "sk-placeholder";
+
 /**
  * The default context if the server didn't expose it
  */

package/src/interfaces/auth.ts

@@ -1,6 +1,6 @@
 import { PROVIDER_ID } from "../constants";
 
-export interface Auth {
+interface Auth {
   type: string;
   key: string;
 }

package/src/models/baseModel.ts

@@ -112,31 +112,26 @@ export abstract class BaseModel {
   /**
    * Unloads the model from llama-server
    */
-
   async unload(): Promise<void> {
     await rpc("/models/unload", { model: this.id });
   }
 
   /**
    * Polls llama-server to check when the model is loaded
+   *
+   * @param startTime The initial polling timestamp
    */
-  async pollStatus(): Promise<void> {
-    const startTime = Date.now();
-
-    // Check loading status
-    try {
-      while ((await this.getStatus()) === Status.LOADING) {
-        // Force a timeout if we wasted too much time polling
-        if (Date.now() - startTime > POLLING_TIMEOUT) {
-          const message = `Model loading timed out after ${POLLING_TIMEOUT} ms: ${this.id}`;
-          throw new Error(message);
-        }
-
-        await new Promise((r) => setTimeout(r, POLLING_INTERVAL));
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
+  async pollStatus(startTime = Date.now()): Promise<void> {
+    const status = await this.getStatus();
+    if (status !== Status.LOADING) return;
+
+    // Force a timeout if we wasted too much time polling
+    if (Date.now() - startTime > POLLING_TIMEOUT) {
+      const message = `Model loading timed out after ${POLLING_TIMEOUT} ms: ${this.id}`;
       throw new Error(message);
     }
+
+    await new Promise((r) => setTimeout(r, POLLING_INTERVAL));
+    await this.pollStatus(startTime);
   }
 }

package/src/models/routerModel.ts

@@ -15,7 +15,7 @@ export class RouterModel extends BaseModel {
   }
 
   get capabilities(): ["text"] | ["image"] {
-    const hasImage = this.model.status!.args?.includes("--mmproj") ?? false;
+    const hasImage = this.model.status?.args?.includes("--mmproj") ?? false;
     return hasImage ? ["image"] : ["text"];
   }
 

package/src/tools/resolver.ts

@@ -1,7 +1,11 @@
 import { access, constants, readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { DEFAULT_LLAMA_SERVER_URL, PROVIDER_ID } from "../constants";
-import { Auth, AuthFile } from "../interfaces/auth";
+import {
+  API_KEY_PLACEHOLDER,
+  DEFAULT_LLAMA_SERVER_URL,
+  PROVIDER_ID,
+} from "../constants";
+import { AuthFile } from "../interfaces/auth";
 
 // The URL is detected once, to reuse forever
 let resolvedUrl: string | undefined;
@@ -42,12 +46,12 @@ const readContents = async <T>(filePath: string): Promise<T | null> => {
  * @param key Key to extract from the parsed JSON
  * @returns The string value, or null if file/key missing or invalid
  */
-const readConfigValue = async <T, U>(
+const readConfigValue = async <T>(
   filePath: string,
-  key: string,
-): Promise<U> => {
+  key: keyof T,
+): Promise<T[keyof T] | null> => {
   const cfg = await readContents<T>(filePath);
-  return (cfg as Record<string, any>)?.[key] || null;
+  return cfg?.[key] ?? null;
 };
 
 /**
@@ -55,16 +59,11 @@ const readConfigValue = async <T, U>(
  * @returns The API key, as defined by the auth.json file
  */
 export const resolveApiKey = async (): Promise<string> => {
-  const placeholder = "sk-placeholder";
-
   const authPath = join(process.env.HOME || ".", ".pi", "agent", "auth.json");
-  if (!(await fileExists(authPath))) return placeholder;
+  if (!(await fileExists(authPath))) return API_KEY_PLACEHOLDER;
 
-  const cfg = await readConfigValue<AuthFile, Auth | null>(
-    authPath,
-    PROVIDER_ID,
-  );
-  return cfg?.key ?? placeholder;
+  const cfg = await readConfigValue<AuthFile>(authPath, PROVIDER_ID);
+  return cfg?.key ?? API_KEY_PLACEHOLDER;
 };
 
 /**
@@ -81,10 +80,7 @@ const resolveGlobalUrl = async (): Promise<string | null> => {
 
   if (!(await fileExists(globalPath))) return null;
 
-  return readConfigValue<Record<string, string>, string>(
-    globalPath,
-    "llamaServerUrl",
-  );
+  return readConfigValue<Record<string, string>>(globalPath, "llamaServerUrl");
 };
 
 /**
@@ -96,7 +92,7 @@ const resolveProjectUrl = async (cwd: string): Promise<string | null> => {
   const projectPath = join(cwd, ".pi", "llama-server.json");
 
   if (!(await fileExists(projectPath))) return null;
-  return readConfigValue<Record<string, string>, string>(projectPath, "url");
+  return readConfigValue<Record<string, string>>(projectPath, "url");
 };
 
 /**

package/tests/handlers.test.ts

@@ -0,0 +1,159 @@
+import { describe, expect, it, vi } from "vitest";
+import { Action } from "../src/enums/action";
+import { Mode } from "../src/enums/mode";
+import { Status } from "../src/enums/status";
+import { DataProperty } from "../src/interfaces/endpoints/models";
+
+// Mock the retriever module before importing anything that depends on it
+vi.mock("../src/tools/retriever", () => ({
+  rpc: vi.fn(),
+  isServerReady: vi.fn(),
+  listModels: vi.fn(),
+}));
+
+class TestModel {
+  constructor(
+    private readonly model: DataProperty,
+    private readonly _mode: Mode,
+    private readonly _status: Status,
+  ) {}
+
+  get mode(): Mode {
+    return this._mode;
+  }
+
+  get capabilities(): ["text"] | ["image"] {
+    return ["text"];
+  }
+
+  async getStatus(): Promise<Status> {
+    return this._status;
+  }
+
+  async getContextSize(): Promise<number> {
+    return 4096;
+  }
+}
+
+const createModel = (
+  mode: Mode,
+  status: Status,
+  overrides: Partial<DataProperty> = {},
+) =>
+  new TestModel(
+    {
+      id: "test",
+      tags: [],
+      object: "model",
+      owned_by: "test",
+      created: Date.now(),
+      ...overrides,
+    },
+    mode,
+    status,
+  );
+
+/**
+ * Replicates the getActionsForModel logic from handlers.ts for testing
+ * without needing the full Pi extension context.
+ */
+const getActionsForModel = async (model: TestModel): Promise<Array<Action>> => {
+  const routerModeActions: Record<Status, Array<Action>> = {
+    [Status.LOADED]: [Action.SWITCH, Action.UNLOAD, Action.INFO, Action.CANCEL],
+    [Status.LOADING]: [Action.INFO, Action.CANCEL],
+    [Status.FAILED]: [Action.RETRY, Action.CANCEL],
+    [Status.SLEEPING]: [Action.UNLOAD, Action.INFO, Action.CANCEL],
+    [Status.UNLOADED]: [Action.LOAD, Action.CANCEL],
+  };
+
+  const singleModeActions: Record<Status, Array<Action>> = {
+    [Status.LOADED]: [Action.INFO, Action.CANCEL],
+    [Status.LOADING]: [Action.CANCEL],
+    [Status.FAILED]: [Action.CANCEL],
+    [Status.SLEEPING]: [Action.INFO, Action.CANCEL],
+    [Status.UNLOADED]: [Action.CANCEL],
+  };
+
+  const allActions =
+    model.mode === Mode.ROUTER ? routerModeActions : singleModeActions;
+
+  const status = await model.getStatus();
+  return allActions[status];
+};
+
+describe("Action availability", () => {
+  const actionMatrix: Array<{
+    mode: Mode;
+    status: Status;
+    expected: Action[];
+  }> = [
+    // Router mode
+    {
+      mode: Mode.ROUTER,
+      status: Status.LOADED,
+      expected: [Action.SWITCH, Action.UNLOAD, Action.INFO, Action.CANCEL],
+    },
+    {
+      mode: Mode.ROUTER,
+      status: Status.LOADING,
+      expected: [Action.INFO, Action.CANCEL],
+    },
+    {
+      mode: Mode.ROUTER,
+      status: Status.FAILED,
+      expected: [Action.RETRY, Action.CANCEL],
+    },
+    {
+      mode: Mode.ROUTER,
+      status: Status.SLEEPING,
+      expected: [Action.UNLOAD, Action.INFO, Action.CANCEL],
+    },
+    {
+      mode: Mode.ROUTER,
+      status: Status.UNLOADED,
+      expected: [Action.LOAD, Action.CANCEL],
+    },
+    // Single mode
+    {
+      mode: Mode.SINGLE,
+      status: Status.LOADED,
+      expected: [Action.INFO, Action.CANCEL],
+    },
+    { mode: Mode.SINGLE, status: Status.LOADING, expected: [Action.CANCEL] },
+    { mode: Mode.SINGLE, status: Status.FAILED, expected: [Action.CANCEL] },
+    {
+      mode: Mode.SINGLE,
+      status: Status.SLEEPING,
+      expected: [Action.INFO, Action.CANCEL],
+    },
+    { mode: Mode.SINGLE, status: Status.UNLOADED, expected: [Action.CANCEL] },
+  ];
+
+  it.each(actionMatrix)(
+    "should return correct actions for $mode/$status",
+    async ({ mode, status, expected }) => {
+      const model = createModel(mode, status);
+      const actions = await getActionsForModel(model);
+      expect(actions).toEqual(expected);
+    },
+  );
+
+  it("should always include CANCEL regardless of mode or status", async () => {
+    for (const mode of [Mode.ROUTER, Mode.SINGLE]) {
+      for (const status of Object.values(Status)) {
+        const model = createModel(mode, status);
+        const actions = await getActionsForModel(model);
+        expect(actions).toContain(Action.CANCEL);
+      }
+    }
+  });
+
+  it("should not include mode-exclusive actions", async () => {
+    const singleLoaded = createModel(Mode.SINGLE, Status.LOADED);
+    expect(await getActionsForModel(singleLoaded)).not.toContain(Action.SWITCH);
+    expect(await getActionsForModel(singleLoaded)).not.toContain(Action.LOAD);
+
+    const singleFailed = createModel(Mode.SINGLE, Status.FAILED);
+    expect(await getActionsForModel(singleFailed)).not.toContain(Action.RETRY);
+  });
+});

package/tests/resolver.test.ts

@@ -0,0 +1,157 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  API_KEY_PLACEHOLDER,
+  DEFAULT_LLAMA_SERVER_URL,
+  PROVIDER_ID,
+} from "../src/constants";
+
+describe("URL resolution fallback chain", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    delete process.env.LLAMA_SERVER_URL;
+  });
+
+  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(""),
+    }));
+
+    const { resolveUrl } = await import("../src/tools/resolver");
+    const result = await resolveUrl("/tmp/test-project");
+
+    expect(result).toBe(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" })),
+    }));
+
+    process.env.LLAMA_SERVER_URL = "http://env-url:8080";
+
+    const { resolveUrl } = await import("../src/tools/resolver");
+    const result = await resolveUrl("/tmp/test-project");
+
+    expect(result).toBe("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");
+
+    expect(result).toBe("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");
+  });
+
+  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/" })),
+    }));
+
+    const { resolveUrl } = await import("../src/tools/resolver");
+    const result = await resolveUrl("/tmp/test-project");
+
+    expect(result).toBe("http://localhost:8080");
+  });
+});
+
+describe("API key resolution", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.resetModules();
+  });
+
+  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 { resolveApiKey } = await import("../src/tools/resolver");
+    const result = await resolveApiKey();
+
+    expect(result).toBe(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);
+  });
+
+  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");
+  });
+});

package/tests/routerModel.test.ts

@@ -0,0 +1,176 @@
+import { describe, expect, it } from "vitest";
+import { Mode } from "../src/enums/mode";
+import { DataProperty } from "../src/interfaces/endpoints/models";
+import { RouterModel } from "../src/models/routerModel";
+
+// Helper to create a mock DataProperty
+const createModel = (overrides: Partial<DataProperty> = {}): DataProperty => ({
+  id: "test-model",
+  aliases: ["test-alias"],
+  tags: [],
+  object: "model",
+  owned_by: "test",
+  created: Date.now(),
+  ...overrides,
+});
+
+describe("RouterModel context size extraction", () => {
+  it("should extract --ctx-size value", () => {
+    const model = new RouterModel(
+      createModel({
+        status: {
+          value: "loaded",
+          args: [
+            "--model",
+            "gguf",
+            "--ctx-size",
+            "4096",
+            "--batch-size",
+            "512",
+          ],
+          preset: "default",
+        },
+      }),
+    );
+
+    // Access the private method via any
+    const extractFrom = (model as any).extractFrom.bind(model);
+    expect(extractFrom("--ctx-size")).toBe(4096);
+  });
+
+  it("should extract --fit-ctx value when --ctx-size is not present", () => {
+    const model = new RouterModel(
+      createModel({
+        status: {
+          value: "loaded",
+          args: ["--model", "gguf", "--fit-ctx", "8192"],
+          preset: "default",
+        },
+      }),
+    );
+
+    const extractFrom = (model as any).extractFrom.bind(model);
+    expect(extractFrom("--fit-ctx")).toBe(8192);
+  });
+
+  it("should return null when argument is not found", () => {
+    const model = new RouterModel(
+      createModel({
+        status: {
+          value: "loaded",
+          args: ["--model", "gguf", "--batch-size", "512"],
+          preset: "default",
+        },
+      }),
+    );
+
+    const extractFrom = (model as any).extractFrom.bind(model);
+    expect(extractFrom("--ctx-size")).toBeNull();
+    expect(extractFrom("--fit-ctx")).toBeNull();
+  });
+
+  it("should return null when argument has no following value", () => {
+    const model = new RouterModel(
+      createModel({
+        status: {
+          value: "loaded",
+          args: ["--model", "gguf", "--ctx-size"],
+          preset: "default",
+        },
+      }),
+    );
+
+    const extractFrom = (model as any).extractFrom.bind(model);
+    expect(extractFrom("--ctx-size")).toBeNull();
+  });
+
+  it("should return null when argument value is not a valid number", () => {
+    const model = new RouterModel(
+      createModel({
+        status: {
+          value: "loaded",
+          args: ["--model", "gguf", "--ctx-size", "not-a-number"],
+          preset: "default",
+        },
+      }),
+    );
+
+    const extractFrom = (model as any).extractFrom.bind(model);
+    expect(extractFrom("--ctx-size")).toBeNull();
+  });
+
+  it("should prefer --ctx-size over --fit-ctx", async () => {
+    const model = new RouterModel(
+      createModel({
+        status: {
+          value: "loaded",
+          args: ["--model", "gguf", "--ctx-size", "4096", "--fit-ctx", "8192"],
+          preset: "default",
+        },
+      }),
+    );
+
+    const ctxSize = await model.getContextSize();
+    expect(ctxSize).toBe(4096);
+  });
+
+  it("should return DEFAULT_CTX when no context size args are present", async () => {
+    const { DEFAULT_CTX } = await import("../src/constants");
+
+    const model = new RouterModel(
+      createModel({
+        status: {
+          value: "loaded",
+          args: ["--model", "gguf"],
+          preset: "default",
+        },
+      }),
+    );
+
+    const ctxSize = await model.getContextSize();
+    expect(ctxSize).toBe(DEFAULT_CTX);
+  });
+});
+
+describe("RouterModel capabilities detection", () => {
+  it("should detect image capability when --mmproj is present", () => {
+    const model = new RouterModel(
+      createModel({
+        status: {
+          value: "loaded",
+          args: ["--model", "gguf", "--mmproj", "mmproj.gguf"],
+          preset: "default",
+        },
+      }),
+    );
+
+    expect(model.capabilities).toEqual(["image"]);
+  });
+
+  it("should detect text-only capability when --mmproj is absent", () => {
+    const model = new RouterModel(
+      createModel({
+        status: {
+          value: "loaded",
+          args: ["--model", "gguf"],
+          preset: "default",
+        },
+      }),
+    );
+
+    expect(model.capabilities).toEqual(["text"]);
+  });
+
+  it("should default to text when status is undefined", () => {
+    const model = new RouterModel(createModel({ status: undefined }));
+
+    expect(model.capabilities).toEqual(["text"]);
+  });
+});
+
+describe("RouterModel mode", () => {
+  it("should always return ROUTER mode", () => {
+    const model = new RouterModel(createModel());
+    expect(model.mode).toBe(Mode.ROUTER);
+  });
+});

package/tests/singleModel.test.ts

@@ -0,0 +1,123 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { DEFAULT_CTX } from "../src/constants";
+import { Mode } from "../src/enums/mode";
+import { Status } from "../src/enums/status";
+import { ModelProperty } 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(),
+}));
+
+beforeEach(() => {
+  mockRpc.mockClear();
+});
+
+const createModel = (extra: Partial<ModelProperty> = {}): SingleModel =>
+  new SingleModel(
+    {
+      id: "test",
+      tags: [],
+      object: "model",
+      owned_by: "test",
+      created: Date.now(),
+    },
+    {
+      name: "test",
+      model: "test.gguf",
+      modified_at: new Date().toISOString(),
+      size: "1B",
+      digest: "abc123",
+      type: "model",
+      description: "test",
+      tags: [],
+      capabilities: [],
+      parameters: "",
+      details: {
+        parent_model: "",
+        format: "",
+        family: "",
+        families: [],
+        parameter_size: "",
+        quantization_level: "",
+      },
+      ...extra,
+    },
+  );
+
+describe("SingleModel mode", () => {
+  it("should always return SINGLE mode", () => {
+    const model = createModel();
+    expect(model.mode).toBe(Mode.SINGLE);
+  });
+});
+
+describe("SingleModel capabilities", () => {
+  it("should detect image capability when multimodal", () => {
+    const model = createModel({ capabilities: ["multimodal"] });
+    expect(model.capabilities).toEqual(["image"]);
+  });
+
+  it("should detect text-only capability when not multimodal", () => {
+    const model = createModel({ capabilities: [] });
+    expect(model.capabilities).toEqual(["text"]);
+  });
+});
+
+describe("SingleModel getStatus", () => {
+  it("should return LOADED when not sleeping", async () => {
+    mockRpc.mockResolvedValueOnce({ is_sleeping: false });
+
+    const model = createModel();
+    const status = await model.getStatus();
+
+    expect(status).toBe(Status.LOADED);
+    expect(mockRpc).toHaveBeenCalledWith("/props");
+  });
+
+  it("should return SLEEPING when is_sleeping is true", async () => {
+    mockRpc.mockResolvedValueOnce({ is_sleeping: true });
+
+    const model = createModel();
+    const status = await model.getStatus();
+
+    expect(status).toBe(Status.SLEEPING);
+  });
+});
+
+describe("SingleModel getContextSize", () => {
+  it("should return n_ctx from /slots endpoint", async () => {
+    mockRpc.mockResolvedValueOnce([{ n_ctx: 8192 }]);
+
+    const model = createModel();
+    const ctxSize = await model.getContextSize();
+
+    expect(ctxSize).toBe(8192);
+    expect(mockRpc).toHaveBeenCalledWith("/slots");
+  });
+
+  it("should cache the context size on first call", async () => {
+    mockRpc.mockResolvedValueOnce([{ n_ctx: 4096 }]);
+
+    const model = createModel();
+    const first = await model.getContextSize();
+    const second = await model.getContextSize();
+
+    expect(first).toBe(4096);
+    expect(second).toBe(4096);
+    expect(mockRpc).toHaveBeenCalledTimes(1);
+  });
+
+  it("should return DEFAULT_CTX when /slots fails", async () => {
+    mockRpc.mockRejectedValueOnce(new Error("Connection refused"));
+
+    const model = createModel();
+    const ctxSize = await model.getContextSize();
+
+    expect(ctxSize).toBe(DEFAULT_CTX);
+  });
+});

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+  },
+});