pi-llama-cpp 0.2.3 → 0.3.1

package/README.md

@@ -99,8 +99,8 @@ llama-server --model path/to/model.gguf ...
 ```
 
 The extension determines the context size as follows:
-- **Router mode** — reads from the preset file's `ctx-size` and/or `fit-ctx` keys
-- **Single mode** — reads from the `/slots` endpoint (stores it in cache afterwards)
+- **Router mode** — when loaded, reads `meta.n_ctx` from the `/models` endpoint; when not loaded, reads `--ctx-size` and/or `--fit-ctx` from the model's status `args` array
+- **Single mode** — reads `meta.n_ctx` from the `/models` endpoint
 - Falls back to `128000` if not available
 
 ### Commands
@@ -145,6 +145,6 @@ Each model exposed to Pi includes the following defaults:
 
 ## Dependencies
 
-| Dependency                      | Purpose                               |
-| ------------------------------- | ------------------------------------- |
-| `@mariozechner/pi-coding-agent` | Pi Coding Agent SDK (peer dependency) |
+| Dependency                        | Purpose                               |
+| --------------------------------- | ------------------------------------- |
+| `@earendil-works/pi-coding-agent` | Pi Coding Agent SDK (peer dependency) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-llama-cpp",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "description": "Pi extension for llama.cpp integration. Supports both router and single modes.",
   "keywords": [
     "pi",
@@ -33,7 +33,7 @@
     ]
   },
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*"
+    "@earendil-works/pi-coding-agent": "*"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",

package/src/{handlers.ts → commands/models.ts}

@@ -1,12 +1,13 @@
 import type {
   ExtensionAPI,
   ExtensionCommandContext,
-} from "@mariozechner/pi-coding-agent";
-import { PROVIDER_ID, PROVIDER_NAME } from "./constants";
-import { Action } from "./enums/action";
-import { Mode } from "./enums/mode";
-import { Status } from "./enums/status";
-import { BaseModel } from "./models/baseModel";
+} from "@earendil-works/pi-coding-agent";
+import { PROVIDER_ID, PROVIDER_NAME } from "../constants";
+import { Action } from "../enums/action";
+import { Mode } from "../enums/mode";
+import { Status } from "../enums/status";
+import { BaseModel } from "../models/baseModel";
+import { resolveUrl } from "../tools/resolver";
 
 /**
  * Select a model from the list. Returns null if user cancels.
@@ -30,7 +31,7 @@ const selectModel = async (
  * Get available actions for a model based on its mode and status.
  *
  * @param model The selected model
- * @returns
+ * @returns The array of available actions for the given model status
  */
 const getActionsForModel = async (model: BaseModel): Promise<Array<Action>> => {
   const routerModeActions: Record<Status, Array<Action>> = {
@@ -109,13 +110,25 @@ const modelSelectionHandler = async (
   }
 };
 
+/**
+ * Handles the /models command when the server is unreachable.
+ *
+ * @param ctx The context used by Pi
+ */
+export const notFoundCommand = async (
+  ctx: ExtensionCommandContext,
+): Promise<void> => {
+  const url = await resolveUrl(ctx.cwd);
+  ctx.ui.notify(`${PROVIDER_NAME} unreachable at ${url}`, "error");
+};
+
 /**
  * Handles the /models command
  *
  * @param ctx The context used by Pi
  * @param pi The Pi extension
  */
-export const modelsCommandHandler = async (
+export const modelsCommand = async (
   ctx: ExtensionCommandContext,
   pi: ExtensionAPI,
   models: BaseModel[],

package/src/events.ts

@@ -1,4 +1,4 @@
-import { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { PROVIDER_ID } from "./constants";
 import { ModelSelectEvent } from "./interfaces/events";
 import { listModels } from "./tools/retriever";

package/src/index.ts

@@ -1,47 +1,34 @@
 import type {
   ExtensionAPI,
   ExtensionCommandContext,
-} from "@mariozechner/pi-coding-agent";
-import { PROVIDER_ID, PROVIDER_NAME } from "./constants";
+} from "@earendil-works/pi-coding-agent";
+import { modelsCommand, notFoundCommand } from "./commands/models";
+import { PROVIDER_NAME } from "./constants";
 import { onModelSelect } from "./events";
-import { modelsCommandHandler } from "./handlers";
-import { resolveApiKey, resolveUrl } from "./tools/resolver";
-import { isServerReady, listModels } from "./tools/retriever";
+import { registerLlamaCppProvider } from "./tools/provider";
+import { isServerReady } from "./tools/retriever";
 
 export default async function (pi: ExtensionAPI) {
-  // Command registration
+  // Server verification
   if (!(await isServerReady())) {
     pi.registerCommand("models", {
       description: `${PROVIDER_NAME} models (offline)`,
-      handler: async (
-        _: string,
-        ctx: ExtensionCommandContext,
-      ): Promise<void> => {
-        const url = await resolveUrl(ctx.cwd);
-        ctx.ui.notify(`${PROVIDER_NAME} unreachable at ${url}`, "error");
+      handler: async (_: string, ctx: ExtensionCommandContext) => {
+        await notFoundCommand(ctx);
       },
     });
 
     return;
   }
 
-  const cwd = process.cwd();
-  const url = await resolveUrl(cwd);
-  const serverModels = await listModels();
+  // Provider registration
+  const serverModels = await registerLlamaCppProvider(pi);
 
+  // Command: /models
   pi.registerCommand("models", {
     description: `Browse ${PROVIDER_NAME} models (live status)`,
     handler: async (_: string, ctx: ExtensionCommandContext) =>
-      await modelsCommandHandler(ctx, pi, serverModels),
-  });
-
-  // Provider registration
-  pi.registerProvider(PROVIDER_ID, {
-    name: PROVIDER_NAME,
-    baseUrl: `${url}/v1`,
-    api: "openai-completions",
-    apiKey: await resolveApiKey(),
-    models: await Promise.all(serverModels.map((m) => m.toProviderConfig())),
+      await modelsCommand(ctx, pi, serverModels),
   });
 
   // Events registration

package/src/interfaces/endpoints/models.ts

@@ -53,6 +53,7 @@ interface StatusProperty {
 interface MetaProperty {
   vocab_type: number;
   n_vocab: number;
+  n_ctx: number;
   n_ctx_train: number;
   n_embd: number;
   n_params: number;

package/src/models/baseModel.ts

@@ -1,10 +1,21 @@
-import type { ProviderModelConfig } from "@mariozechner/pi-coding-agent";
-import { MAX_TOKENS, POLLING_INTERVAL, POLLING_TIMEOUT } from "../constants";
+import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+import {
+  DEFAULT_CTX,
+  MAX_TOKENS,
+  POLLING_INTERVAL,
+  POLLING_TIMEOUT,
+} from "../constants";
 import { Mode } from "../enums/mode";
 import { Status } from "../enums/status";
-import { DataProperty } from "../interfaces/endpoints/models";
+import { DataProperty, ModelsEndpoint } from "../interfaces/endpoints/models";
+import { PropsEndpoint } from "../interfaces/endpoints/props";
 import { rpc } from "../tools/retriever";
 
+/**
+ * Abstract base class for llama-server models.
+ * Provides common functionality for model identification, status checking,
+ * loading/unloading, and configuration conversion.
+ */
 export abstract class BaseModel {
   constructor(protected readonly model: DataProperty) {}
 
@@ -40,9 +51,21 @@ export abstract class BaseModel {
   }
 
   /**
-   * Detects if the model can load images
+   * Detects the capabilities of the model
+   *
+   * @returns An array of capabilities, as expected by Pi
    */
-  abstract get capabilities(): ["text"] | ["image"];
+  async getCapabilities(): Promise<["text"] | ["image"]> {
+    try {
+      const { modalities } = await rpc<PropsEndpoint>(
+        `/props?model=${this.id}`,
+      );
+
+      return modalities.vision ? ["image"] : ["text"];
+    } catch {
+      return ["text"];
+    }
+  }
 
   /**
    * Gets the load status of the model
@@ -52,7 +75,17 @@ export abstract class BaseModel {
   /**
    * Gets the context size of a particular model
    */
-  abstract getContextSize(): Promise<number>;
+  async getContextSize(): Promise<number> {
+    try {
+      const { data } = await rpc<ModelsEndpoint>(`/models`);
+      const model = data.find((d) => d.id === this.id);
+
+      const response = model?.meta?.n_ctx;
+      return response ?? DEFAULT_CTX;
+    } catch {
+      return DEFAULT_CTX;
+    }
+  }
 
   /**
    * Sets up a label for the model selection screen
@@ -72,7 +105,7 @@ export abstract class BaseModel {
       `ID           : ${this.id}`,
       `Model        : ${this.name}`,
       `Reasoning    : ${this.reasoning}`,
-      `Capabilities : ${this.capabilities.join(", ")}`,
+      `Capabilities : ${(await this.getCapabilities()).join(", ")}`,
       `Context size : ${await this.getContextSize()}`,
       `Status       : ${await this.getStatus()}`,
     ];
@@ -90,7 +123,7 @@ export abstract class BaseModel {
       id: this.id,
       name: this.name,
       reasoning: this.reasoning,
-      input: this.capabilities,
+      input: await this.getCapabilities(),
       contextWindow: await this.getContextSize(),
       cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
       maxTokens: MAX_TOKENS,
@@ -122,16 +155,13 @@ export abstract class BaseModel {
    * @param startTime The initial polling timestamp
    */
   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);
+    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));
     }
-
-    await new Promise((r) => setTimeout(r, POLLING_INTERVAL));
-    await this.pollStatus(startTime);
   }
 }

package/src/models/routerModel.ts

@@ -1,24 +1,20 @@
 import { DEFAULT_CTX } from "../constants";
 import { Mode } from "../enums/mode";
 import { Status } from "../enums/status";
-import { DataProperty, ModelsEndpoint } from "../interfaces/endpoints/models";
+import { ModelsEndpoint } from "../interfaces/endpoints/models";
 import { rpc } from "../tools/retriever";
 import { BaseModel } from "./baseModel";
 
+/**
+ * Represents a model in llama-server router mode.
+ * Tracks per-model status from the /models endpoint and extracts
+ * context size from startup arguments when the model is not loaded.
+ */
 export class RouterModel extends BaseModel {
-  constructor(protected readonly model: DataProperty) {
-    super(model);
-  }
-
   get mode(): Mode {
     return Mode.ROUTER;
   }
 
-  get capabilities(): ["text"] | ["image"] {
-    const hasImage = this.model.status?.args?.includes("--mmproj") ?? false;
-    return hasImage ? ["image"] : ["text"];
-  }
-
   async getStatus(): Promise<Status> {
     const { data } = await rpc<ModelsEndpoint>("/models");
     const model = data.find((m) => m.id === this.id);
@@ -34,14 +30,28 @@ export class RouterModel extends BaseModel {
     return status;
   }
 
+  async getCapabilities(): Promise<["text"] | ["image"]> {
+    // We can get the real capabilities if the model is already loaded
+    if ((await this.getStatus()) === Status.LOADED) {
+      return super.getCapabilities();
+    }
+
+    const hasImage = this.model.status?.args?.includes("--mmproj") ?? false;
+    return hasImage ? ["image"] : ["text"];
+  }
+
   async getContextSize(): Promise<number> {
-    let response = this.extractFrom("--ctx-size");
-    if (response) return response;
+    // We can get a more accurate context size if the model is already loaded
+    if ((await this.getStatus()) === Status.LOADED) {
+      return super.getContextSize();
+    }
 
-    response = this.extractFrom("--fit-ctx");
-    if (response) return response;
+    const response =
+      this.extractFrom("--ctx-size") ??
+      this.extractFrom("--fit-ctx") ??
+      DEFAULT_CTX;
 
-    return DEFAULT_CTX;
+    return response;
   }
 
   /**

package/src/models/singleModel.ts

@@ -1,31 +1,14 @@
-import { DEFAULT_CTX } from "../constants";
 import { Mode } from "../enums/mode";
 import { Status } from "../enums/status";
-import { DataProperty, ModelProperty } from "../interfaces/endpoints/models";
 import { PropsEndpoint } from "../interfaces/endpoints/props";
-import { SlotsEndpoint } from "../interfaces/endpoints/slots";
 import { rpc } from "../tools/retriever";
 import { BaseModel } from "./baseModel";
 
 export class SingleModel extends BaseModel {
-  private contextSize?: number;
-
-  constructor(
-    protected readonly model: DataProperty,
-    private readonly extra: ModelProperty,
-  ) {
-    super(model);
-  }
-
   get mode(): Mode {
     return Mode.SINGLE;
   }
 
-  get capabilities(): ["text"] | ["image"] {
-    const hasImage = this.extra.capabilities.includes("multimodal");
-    return hasImage ? ["image"] : ["text"];
-  }
-
   async getStatus(): Promise<Status> {
     // In single-mode, the extension will only work when the model is fully loaded
     const { is_sleeping } = await rpc<PropsEndpoint>("/props");
@@ -33,18 +16,4 @@ export class SingleModel extends BaseModel {
 
     return Status.LOADED;
   }
-
-  async getContextSize(): Promise<number> {
-    // Avoid calling the endpoint if we already have the value
-    if (this.contextSize) return this.contextSize;
-
-    try {
-      const [{ n_ctx }] = await rpc<SlotsEndpoint[]>("/slots");
-      this.contextSize = n_ctx;
-
-      return this.contextSize;
-    } catch {
-      return DEFAULT_CTX;
-    }
-  }
 }

package/src/tools/provider.ts

@@ -0,0 +1,28 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { PROVIDER_ID, PROVIDER_NAME } from "../constants";
+import type { BaseModel } from "../models/baseModel";
+import { resolveApiKey, resolveUrl } from "./resolver";
+import { listModels } from "./retriever";
+
+/**
+ * Registers the Llama.cpp provider and returns the fetched models.
+ *
+ * @param pi The Pi extension API
+ * @returns The list of models fetched from the server
+ */
+export const registerLlamaCppProvider = async (
+  pi: ExtensionAPI,
+): Promise<BaseModel[]> => {
+  const baseUrl = `${await resolveUrl(process.cwd())}/v1`;
+  const models = await listModels();
+
+  pi.registerProvider(PROVIDER_ID, {
+    name: PROVIDER_NAME,
+    baseUrl,
+    api: "openai-completions",
+    apiKey: await resolveApiKey(),
+    models: await Promise.all(models.map((m) => m.toProviderConfig())),
+  });
+
+  return models;
+};

package/src/tools/resolver.ts

@@ -25,9 +25,9 @@ const fileExists = async (filePath: string): Promise<boolean> => {
 };
 
 /**
- * Reads the contents of a file as JSON
- * @param filePath The path
- * @returns The content as JSON
+ * Reads and parses the contents of a file as JSON
+ * @param filePath The path to the file
+ * @returns The parsed content, or null if parsing fails
  */
 const readContents = async <T>(filePath: string): Promise<T | null> => {
   const raw = await readFile(filePath, "utf-8");
@@ -41,10 +41,10 @@ const readContents = async <T>(filePath: string): Promise<T | null> => {
 };
 
 /**
- * Reads a string value from a JSON config file
+ * Reads a value from a JSON config file by key
  * @param filePath Path to the JSON config file
  * @param key Key to extract from the parsed JSON
- * @returns The string value, or null if file/key missing or invalid
+ * @returns The value at the given key, or null if file/key missing or invalid
  */
 const readConfigValue = async <T>(
   filePath: string,

package/src/tools/retriever.ts

@@ -19,10 +19,11 @@ export const isServerReady = async (): Promise<boolean> => {
 };
 
 /**
- * Extracts the data of a fetch command
- * @param endpoint The endpoint to fetch from
- * @param body The body (optional)
- * @returns Data from the fetch command
+ * Makes an HTTP request to the llama-server and returns the parsed JSON response
+ *
+ * @param endpoint The endpoint path to fetch (e.g. "/health")
+ * @param body The optional request body for POST requests
+ * @returns The parsed JSON response from the server
  */
 export const rpc = async <T>(
   endpoint: string,
@@ -46,11 +47,8 @@ export const rpc = async <T>(
     },
   });
 
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`${res.status}: ${text}`);
-  }
-  return res.json() as T;
+  const response: T = await res.json();
+  return response;
 };
 
 /**
@@ -62,8 +60,7 @@ export const listModels = async (): Promise<BaseModel[]> => {
   const { models, data } = await rpc<ModelsEndpoint>("/models");
 
   if (models) {
-    const [extra] = models;
-    return data.map((m) => new SingleModel(m, extra));
+    return data.map((m) => new SingleModel(m));
   }
 
   const response = data

package/tests/routerModel.test.ts

@@ -1,8 +1,17 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } 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(),
+}));
+
 // Helper to create a mock DataProperty
 const createModel = (overrides: Partial<DataProperty> = {}): DataProperty => ({
   id: "test-model",
@@ -11,6 +20,7 @@ const createModel = (overrides: Partial<DataProperty> = {}): DataProperty => ({
   object: "model",
   owned_by: "test",
   created: Date.now(),
+  status: { value: "loaded", args: [], preset: "default", failed: false },
   ...overrides,
 });
 
@@ -99,7 +109,26 @@ describe("RouterModel context size extraction", () => {
     expect(extractFrom("--ctx-size")).toBeNull();
   });
 
-  it("should prefer --ctx-size over --fit-ctx", async () => {
+  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
+    mockRpc.mockResolvedValueOnce({
+      data: [
+        {
+          id: "test-model",
+          meta: { n_ctx: 4096 },
+        },
+      ],
+    });
+
     const model = new RouterModel(
       createModel({
         status: {
@@ -114,7 +143,25 @@ describe("RouterModel context size extraction", () => {
     expect(ctxSize).toBe(4096);
   });
 
-  it("should return DEFAULT_CTX when no context size args are present", async () => {
+  it("should return DEFAULT_CTX when no context size args are present and loaded", async () => {
+    // First call: getStatus() -> /models
+    mockRpc.mockResolvedValueOnce({
+      data: [
+        {
+          id: "test-model",
+          status: { value: "loaded", args: ["--model", "gguf"], preset: "default" },
+        },
+      ],
+    });
+    // Second call: super.getContextSize() -> /models without meta.n_ctx
+    mockRpc.mockResolvedValueOnce({
+      data: [
+        {
+          id: "test-model",
+        },
+      ],
+    });
+
     const { DEFAULT_CTX } = await import("../src/constants");
 
     const model = new RouterModel(
@@ -133,38 +180,104 @@ describe("RouterModel context size extraction", () => {
 });
 
 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",
+  it("should detect image capability when modalities.vision is true", async () => {
+    // getStatus() calls /models first
+    mockRpc.mockResolvedValueOnce({
+      data: [
+        {
+          id: "test-model",
+          status: { value: "loaded", args: [], preset: "default", failed: false },
         },
-      }),
-    );
+      ],
+    });
+    // super.getCapabilities() calls /props?model=<id>
+    mockRpc.mockResolvedValueOnce({ modalities: { vision: true } });
+
+    const model = new RouterModel(createModel());
+    const capabilities = await model.getCapabilities();
+
+    expect(capabilities).toEqual(["image"]);
+    expect(mockRpc).toHaveBeenCalledWith("/props?model=test-model");
+  });
+
+  it("should detect text-only capability when modalities.vision is false", async () => {
+    // getStatus() calls /models first
+    mockRpc.mockResolvedValueOnce({
+      data: [
+        {
+          id: "test-model",
+          status: { value: "loaded", args: [], preset: "default", failed: false },
+        },
+      ],
+    });
+    // super.getCapabilities() calls /props?model=<id>
+    mockRpc.mockResolvedValueOnce({ modalities: { vision: false } });
 
-    expect(model.capabilities).toEqual(["image"]);
+    const model = new RouterModel(createModel());
+    const capabilities = await model.getCapabilities();
+
+    expect(capabilities).toEqual(["text"]);
   });
 
-  it("should detect text-only capability when --mmproj is absent", () => {
+  it("should default to text when /props call fails", async () => {
+    // getStatus() calls /models first
+    mockRpc.mockResolvedValueOnce({
+      data: [
+        {
+          id: "test-model",
+          status: { value: "loaded", args: [], preset: "default", failed: false },
+        },
+      ],
+    });
+    // super.getCapabilities() calls /props?model=<id> which fails
+    mockRpc.mockRejectedValueOnce(new Error("Connection refused"));
+
+    const model = new RouterModel(createModel());
+    const capabilities = await model.getCapabilities();
+
+    expect(capabilities).toEqual(["text"]);
+  });
+
+  it("should use status.args to detect image capability when not loaded", async () => {
+    // getStatus() calls /models first, returns unloaded
+    mockRpc.mockResolvedValueOnce({
+      data: [
+        {
+          id: "test-model",
+          status: { value: "unloaded", args: ["--model", "gguf", "--mmproj", "mmproj.gguf"], preset: "default", failed: false },
+        },
+      ],
+    });
+
     const model = new RouterModel(
       createModel({
-        status: {
-          value: "loaded",
-          args: ["--model", "gguf"],
-          preset: "default",
-        },
+        status: { value: "unloaded", args: ["--model", "gguf", "--mmproj", "mmproj.gguf"], preset: "default", failed: false },
       }),
     );
+    const capabilities = await model.getCapabilities();
 
-    expect(model.capabilities).toEqual(["text"]);
+    expect(capabilities).toEqual(["image"]);
   });
 
-  it("should default to text when status is undefined", () => {
-    const model = new RouterModel(createModel({ status: undefined }));
+  it("should return text when not loaded and no --mmproj in args", async () => {
+    // getStatus() calls /models first, returns unloaded
+    mockRpc.mockResolvedValueOnce({
+      data: [
+        {
+          id: "test-model",
+          status: { value: "unloaded", args: ["--model", "gguf"], preset: "default", failed: false },
+        },
+      ],
+    });
+
+    const model = new RouterModel(
+      createModel({
+        status: { value: "unloaded", args: ["--model", "gguf"], preset: "default", failed: false },
+      }),
+    );
+    const capabilities = await model.getCapabilities();
 
-    expect(model.capabilities).toEqual(["text"]);
+    expect(capabilities).toEqual(["text"]);
   });
 });
 

package/tests/singleModel.test.ts

@@ -57,14 +57,32 @@ describe("SingleModel mode", () => {
 });
 
 describe("SingleModel capabilities", () => {
-  it("should detect image capability when multimodal", () => {
-    const model = createModel({ capabilities: ["multimodal"] });
-    expect(model.capabilities).toEqual(["image"]);
+  it("should detect image capability when modalities.vision is true", async () => {
+    mockRpc.mockResolvedValueOnce({ modalities: { vision: true } });
+
+    const model = createModel();
+    const capabilities = await model.getCapabilities();
+
+    expect(capabilities).toEqual(["image"]);
+    expect(mockRpc).toHaveBeenCalledWith("/props?model=test");
+  });
+
+  it("should detect text-only capability when modalities.vision is false", async () => {
+    mockRpc.mockResolvedValueOnce({ modalities: { vision: false } });
+
+    const model = createModel();
+    const capabilities = await model.getCapabilities();
+
+    expect(capabilities).toEqual(["text"]);
   });
 
-  it("should detect text-only capability when not multimodal", () => {
-    const model = createModel({ capabilities: [] });
-    expect(model.capabilities).toEqual(["text"]);
+  it("should return text when /props call fails", async () => {
+    mockRpc.mockRejectedValueOnce(new Error("Connection refused"));
+
+    const model = createModel();
+    const capabilities = await model.getCapabilities();
+
+    expect(capabilities).toEqual(["text"]);
   });
 });
 
@@ -90,29 +108,28 @@ describe("SingleModel getStatus", () => {
 });
 
 describe("SingleModel getContextSize", () => {
-  it("should return n_ctx from /slots endpoint", async () => {
-    mockRpc.mockResolvedValueOnce([{ n_ctx: 8192 }]);
+  it("should return n_ctx from /models endpoint meta", async () => {
+    mockRpc.mockResolvedValueOnce({
+      data: [{ id: "test", meta: { n_ctx: 8192 } }],
+    });
 
     const model = createModel();
     const ctxSize = await model.getContextSize();
 
     expect(ctxSize).toBe(8192);
-    expect(mockRpc).toHaveBeenCalledWith("/slots");
+    expect(mockRpc).toHaveBeenCalledWith("/models");
   });
 
-  it("should cache the context size on first call", async () => {
-    mockRpc.mockResolvedValueOnce([{ n_ctx: 4096 }]);
+  it("should return DEFAULT_CTX when model not found in /models", async () => {
+    mockRpc.mockResolvedValueOnce({ data: [] });
 
     const model = createModel();
-    const first = await model.getContextSize();
-    const second = await model.getContextSize();
+    const ctxSize = await model.getContextSize();
 
-    expect(first).toBe(4096);
-    expect(second).toBe(4096);
-    expect(mockRpc).toHaveBeenCalledTimes(1);
+    expect(ctxSize).toBe(DEFAULT_CTX);
   });
 
-  it("should return DEFAULT_CTX when /slots fails", async () => {
+  it("should return DEFAULT_CTX when /models fails", async () => {
     mockRpc.mockRejectedValueOnce(new Error("Connection refused"));
 
     const model = createModel();

package/tsconfig.json

@@ -1,13 +1,12 @@
 {
   "compilerOptions": {
-    "target": "ES2020",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
     "strict": true,
     "esModuleInterop": true,
     "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "types": ["node"]
+    "noEmit": true
   },
-  "include": ["src/**/*.ts"]
+  "include": ["src/**/*.ts", "tests/**/*.ts"]
 }

package/src/interfaces/endpoints/slots.ts

@@ -1,15 +0,0 @@
-/**
- * The structure of llama-server's /slots endpoint
- *
- * In single mode, applies to /slots
- * In router mode, applies to /slots?model=<id>
- */
-export interface SlotsEndpoint {
-  id: number;
-  n_ctx: number;
-  speculative: boolean;
-  is_processing: boolean;
-  id_task?: number;
-  params?: Array<Record<string, any>>;
-  next_token?: Array<Record<string, any>>;
-}