pi-llama-cpp 0.9.2 → 0.10.0

package/src/models/baseModel.ts

@@ -1,5 +1,5 @@
 import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
-import { DEFAULT_CTX, POLLING_INTERVAL, POLLING_TIMEOUT } from "../constants";
+import { FALLBACK_CTX, POLLING_INTERVAL } from "../constants";
 import { Mode } from "../enums/mode";
 import { Status } from "../enums/status";
 import { DataProperty } from "../interfaces/endpoints/models";
@@ -130,9 +130,9 @@ export abstract class BaseModel {
       const { data } = await this.server.fetchModels();
       const { n_ctx } = data.find((m) => m.id === this.id)?.meta!;
 
-      return n_ctx ?? DEFAULT_CTX;
+      return n_ctx ?? FALLBACK_CTX;
     } catch {
-      return DEFAULT_CTX;
+      return FALLBACK_CTX;
     }
   }
 
@@ -202,11 +202,31 @@ export abstract class BaseModel {
     await this.server.postRequest("load", this.id);
 
     if (await this.server.sseManager.probeSSE()) {
-      const { status, exit_code } =
-        await this.server.sseManager.subscribeToStatus(this.id);
+      try {
+        const { status, exit_code } =
+          await this.server.sseManager.subscribeToStatus(this.id);
 
-      if (status === "failed" || (status === "unloaded" && exit_code !== 0)) {
-        throw new Error(`Model loading failed: ${this.id}`);
+        if (status === "failed" || (status === "unloaded" && exit_code !== 0)) {
+          throw new Error(`Model loading failed: ${this.id}`);
+        }
+      } catch (err) {
+        // A real failed status from the server stays fatal.
+        if (
+          err instanceof Error &&
+          err.message.startsWith("Model loading failed")
+        ) {
+          throw err;
+        }
+        // An SSE timeout or connection failure is not proof the load failed:
+        // subscribeToStatus timers are only cleared by a terminal event on
+        // the same SSE connection, so a timer orphaned by a server restart
+        // or reconnect can fire during a later, healthy load. Check the
+        // model's real status over HTTP before surfacing an error.
+        await this.pollStatus();
+        const finalStatus = await this.getStatus();
+        if (finalStatus !== Status.LOADED && finalStatus !== Status.SLEEPING) {
+          throw new Error(`Model loading failed: ${this.id}`);
+        }
       }
     } else {
       await this.pollStatus();
@@ -224,14 +244,17 @@ export abstract class BaseModel {
    * Polls llama-server to check when the model is loaded
    *
    * @param startTime The initial polling timestamp
-   * @param timeout The maximum amount of ms before timeout. Defaults to POLLING_TIMEOUT
+   * @param timeout The maximum amount of ms before timeout. Defaults to server's pollingTimeout
    * @param interval The polling interval. Defaults to POLLING_INTERVAL
    */
   async pollStatus(
     startTime: number = Date.now(),
-    timeout: number = POLLING_TIMEOUT,
+    timeout?: number,
     interval: number = POLLING_INTERVAL,
   ): Promise<void> {
+    if (timeout === undefined) {
+      timeout = this.server.pollingTimeout;
+    }
     while ((await this.getStatus()) === Status.LOADING) {
       // Force a timeout if we wasted too much time polling
       if (Date.now() - startTime > timeout) {

package/src/models/legacyModel.ts

@@ -1,4 +1,4 @@
-import { DEFAULT_CTX } from "../constants";
+import { FALLBACK_CTX } from "../constants";
 import { Mode } from "../enums/mode";
 import { SingleModel } from "./singleModel";
 
@@ -25,7 +25,7 @@ export class LegacyModel extends SingleModel {
     const [{ max_model_len }] = data;
     const contextSize = max_model_len === 0 ? n_ctx : max_model_len;
 
-    return contextSize ?? DEFAULT_CTX;
+    return contextSize ?? FALLBACK_CTX;
   }
 
   /**

package/src/models/routerModel.ts

@@ -1,4 +1,4 @@
-import { DEFAULT_CTX, POLLING_INTERVAL, POLLING_TIMEOUT } from "../constants";
+import { FALLBACK_CTX, POLLING_INTERVAL } from "../constants";
 import { Mode } from "../enums/mode";
 import { Status } from "../enums/status";
 import { BaseModel } from "./baseModel";
@@ -41,7 +41,7 @@ export class RouterModel extends BaseModel {
       }
     }
 
-    const timeout = POLLING_TIMEOUT - elapsed;
+    const timeout = this.server.pollingTimeout - elapsed;
     return await super.pollStatus(startTime, timeout);
   }
 
@@ -60,7 +60,7 @@ export class RouterModel extends BaseModel {
     const response =
       this.extractFrom("--ctx-size") ??
       this.extractFrom("--fit-ctx") ??
-      DEFAULT_CTX;
+      FALLBACK_CTX;
 
     return response;
   }

package/src/server.ts

@@ -1,5 +1,11 @@
 import { ApiClient } from "./api/client";
-import { PROVIDER_NAME, PROVIDER_PREFIX } from "./constants";
+import {
+  API_KEY_PLACEHOLDER,
+  POLLING_TIMEOUT,
+  PROVIDER_NAME,
+  PROVIDER_PREFIX,
+  SERVER_TIMEOUT,
+} from "./constants";
 import { Mode } from "./enums/mode";
 import { ServerStatus } from "./enums/serverStatus";
 import { HealthEndpoint } from "./interfaces/endpoints/health";
@@ -8,20 +14,25 @@ import {
   PropsEndpoint,
   PropsModelEndpoint,
 } from "./interfaces/endpoints/props";
+import { settings } from "./managers/settings";
 import { BaseModel } from "./models/baseModel";
 import { LegacyModel } from "./models/legacyModel";
 import { RouterModel } from "./models/routerModel";
 import { SingleModel } from "./models/singleModel";
-import { ConfigResolver } from "./resolver";
 import { SSEManager } from "./sse/manager";
 
 export class Server {
   public readonly models: BaseModel[] = [];
-  private configResolver = new ConfigResolver();
   private apiClient!: ApiClient;
   private sse!: SSEManager;
 
-  constructor(readonly baseUrl: string) {}
+  constructor(
+    readonly baseUrl: string,
+    private readonly customId?: string,
+    private readonly customName?: string,
+    readonly serverTimeout: number = SERVER_TIMEOUT,
+    readonly pollingTimeout: number = POLLING_TIMEOUT,
+  ) {}
 
   /**
    * Provides access to the SSE manager for direct subscriptions.
@@ -32,24 +43,37 @@ export class Server {
 
   /**
    * Generates a unique provider ID from a server URL.
+   * Uses custom ID if provided, otherwise falls back to URL-based ID.
    */
   get providerId(): string {
-    return `${PROVIDER_PREFIX}=${this.baseUrl}`;
+    return this.customId ?? `${PROVIDER_PREFIX}=${this.baseUrl}`;
   }
 
   /**
    * Generates a human-readable provider name from a server URL.
+   * Uses custom name as suffix if provided.
    */
   get providerName(): string {
+    if (this.customName) {
+      return `${PROVIDER_NAME} (${this.customName})`;
+    }
     return `${PROVIDER_NAME} (${this.baseUrl})`;
   }
 
   /**
-   * Retrieves the API key from the resolver
+   * Retrieves the API key from the config resolver.
+   * Tries custom ID first, then falls back to URL-based ID.
+   *
    * @returns The API key
    */
-  async getApiKey(): Promise<string> {
-    return await this.configResolver.resolveApiKey(this.providerId);
+  getApiKey(): string {
+    // Try custom ID first
+    if (this.customId) {
+      const key = settings.resolveApiKey(this.customId);
+      if (key !== API_KEY_PLACEHOLDER) return key;
+    }
+    // Fall back to URL-based ID
+    return settings.resolveApiKey(`${PROVIDER_PREFIX}=${this.baseUrl}`);
   }
 
   /**
@@ -59,7 +83,7 @@ export class Server {
   async initialize() {
     const apiKey = await this.getApiKey();
     this.apiClient = new ApiClient(this.baseUrl, apiKey);
-    this.sse = new SSEManager(this.baseUrl, apiKey);
+    this.sse = new SSEManager(this.baseUrl, apiKey, this.serverTimeout);
     const { data } = await this.fetchModels();
     const mode = await this.detectServerMode();
 

package/src/sse/manager.ts

@@ -27,6 +27,7 @@ export class SSEManager {
   constructor(
     private readonly baseUrl: string,
     private readonly apiKey: string,
+    readonly serverTimeout: number = SERVER_TIMEOUT,
   ) {}
 
   /**
@@ -52,7 +53,7 @@ export class SSEManager {
       }
       const response = await fetch(url, {
         method: "GET",
-        signal: AbortSignal.timeout(SERVER_TIMEOUT),
+        signal: AbortSignal.timeout(this.serverTimeout),
       });
       this.sseSupported =
         response.ok &&

package/tests/events.test.ts

@@ -1,7 +1,25 @@
 import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import { DEFAULT_THINKING_BUDGETS } from "../src/constants";
+import { THINKING_BUDGETS } from "../src/constants";
+import { Status } from "../src/enums/status";
 import { createMockModel, createMockServer } from "./mocks";
 
+// Mock settings — reactToModelSelect and autoloadOnMessage
+const mockSettings = {
+  resolveReactToModelSelect: vi.fn(() => true),
+  resolveAutoloadOnMessage: vi.fn(() => false),
+  resolveThinkingLevel: vi.fn(() => "medium"),
+  resolveThinkingBudgets: vi.fn(() => ({ ...THINKING_BUDGETS })),
+};
+
+// Wire resolveThinkingBudgets to use the SettingsManager mock when set
+mockSettings.resolveThinkingBudgets.mockImplementation(() => {
+  const userBudgets = mockSettingsManager.getThinkingBudgets();
+  if (userBudgets) {
+    return { ...THINKING_BUDGETS, ...userBudgets };
+  }
+  return { ...THINKING_BUDGETS };
+});
+
 // Create a mutable mock object shared across tests
 const mockSettingsManager = {
   getDefaultThinkingLevel: vi.fn(() => "medium"),
@@ -19,6 +37,10 @@ vi.mock("@earendil-works/pi-coding-agent", async (importOriginal) => {
   };
 });
 
+vi.mock("../src/managers/settings", () => ({
+  settings: mockSettings,
+}));
+
 let EventManager: typeof import("../src/managers/events").EventManager;
 
 beforeAll(async () => {
@@ -117,7 +139,7 @@ describe("EventManager.onBeforeProviderRequest", () => {
 
       expect(result.messages).toEqual([{ role: "user", content: "test" }]);
       expect(result.temperature).toBe(0.7);
-      expect(result.thinking_budget_tokens).toBe(DEFAULT_THINKING_BUDGETS.low);
+      expect(result.thinking_budget_tokens).toBe(THINKING_BUDGETS.low);
     });
   });
 
@@ -194,9 +216,7 @@ describe("EventManager.onBeforeProviderRequest", () => {
       )) as Record<string, unknown>;
 
       // medium uses default since user only overrode low
-      expect(result.thinking_budget_tokens).toBe(
-        DEFAULT_THINKING_BUDGETS.medium,
-      );
+      expect(result.thinking_budget_tokens).toBe(THINKING_BUDGETS.medium);
     });
   });
 
@@ -223,9 +243,7 @@ describe("EventManager.onBeforeProviderRequest", () => {
       )) as Record<string, unknown>;
 
       // Should fall back to default since "medium" is not in user budgets
-      expect(result.thinking_budget_tokens).toBe(
-        DEFAULT_THINKING_BUDGETS.medium,
-      );
+      expect(result.thinking_budget_tokens).toBe(THINKING_BUDGETS.medium);
     });
 
     it("should not allow overriding 'off' — thinking stays disabled", async () => {
@@ -290,7 +308,125 @@ describe("EventManager.onBeforeProviderRequest", () => {
         ctx,
       )) as Record<string, unknown>;
 
-      expect(result.thinking_budget_tokens).toBe(DEFAULT_THINKING_BUDGETS.high);
+      expect(result.thinking_budget_tokens).toBe(THINKING_BUDGETS.high);
+    });
+  });
+});
+
+describe("EventManager.onModelSelect", () => {
+  beforeEach(() => {
+    mockSettings.resolveReactToModelSelect.mockReturnValue(true);
+  });
+
+  it("should load the model when reactToModelSelect is true", async () => {
+    const server = createMockServer({
+      models: ["model-a"].map((id) => createMockModel(id)),
+    });
+    const eventManager = new EventManager([server]);
+    const ctx = createMockCtx();
+
+    const event = {
+      model: { provider: server.providerId, id: "model-a" },
+    } as any;
+
+    await eventManager.onModelSelect(event, ctx);
+
+    expect(ctx.ui.notify).toHaveBeenCalledWith("Loading model-a...", "info");
+  });
+
+  it("should return early when reactToModelSelect is false", async () => {
+    mockSettings.resolveReactToModelSelect.mockReturnValue(false);
+
+    const server = createMockServer({
+      models: ["model-a"].map((id) => createMockModel(id)),
     });
+    const eventManager = new EventManager([server]);
+    const ctx = createMockCtx();
+
+    const event = {
+      model: { provider: server.providerId, id: "model-a" },
+    } as any;
+
+    await eventManager.onModelSelect(event, ctx);
+
+    expect(ctx.ui.notify).not.toHaveBeenCalled();
+  });
+});
+
+describe("EventManager.autoLoadIfNeeded", () => {
+  it("should load the model when autoloadOnMessage is true and model is UNLOADED", async () => {
+    mockSettings.resolveAutoloadOnMessage.mockReturnValue(true);
+
+    const server = createMockServer({
+      models: [
+        createMockModel("model-a", {
+          getStatus: vi.fn().mockResolvedValue(Status.UNLOADED),
+          load: vi.fn().mockResolvedValue(undefined),
+        }),
+      ],
+    });
+    const eventManager = new EventManager([server]);
+    const model = server.models[0];
+
+    await (eventManager as any).autoLoadIfNeeded(model);
+
+    expect(model.load).toHaveBeenCalled();
+  });
+
+  it("should not load the model when autoloadOnMessage is false", async () => {
+    mockSettings.resolveAutoloadOnMessage.mockReturnValue(false);
+
+    const server = createMockServer({
+      models: [
+        createMockModel("model-a", {
+          getStatus: vi.fn().mockResolvedValue(Status.UNLOADED),
+          load: vi.fn().mockResolvedValue(undefined),
+        }),
+      ],
+    });
+    const eventManager = new EventManager([server]);
+    const model = server.models[0];
+
+    await (eventManager as any).autoLoadIfNeeded(model);
+
+    expect(model.load).not.toHaveBeenCalled();
+  });
+
+  it("should not load the model when model is already LOADED", async () => {
+    mockSettings.resolveAutoloadOnMessage.mockReturnValue(true);
+
+    const server = createMockServer({
+      models: [
+        createMockModel("model-a", {
+          getStatus: vi.fn().mockResolvedValue(Status.LOADED),
+          load: vi.fn().mockResolvedValue(undefined),
+        }),
+      ],
+    });
+    const eventManager = new EventManager([server]);
+    const model = server.models[0];
+
+    await (eventManager as any).autoLoadIfNeeded(model);
+
+    expect(model.load).not.toHaveBeenCalled();
+  });
+
+  it("should not load the model when model is SLEEPING", async () => {
+    mockSettings.resolveAutoloadOnMessage.mockReturnValue(true);
+
+    const server = createMockServer({
+      models: [
+        createMockModel("model-a", {
+          getStatus: vi.fn().mockResolvedValue(Status.SLEEPING),
+          load: vi.fn().mockResolvedValue(undefined),
+        }),
+      ],
+    });
+    const eventManager = new EventManager([server]);
+    const model = server.models[0];
+
+    await (eventManager as any).autoLoadIfNeeded(model);
+
+    expect(model.load).not.toHaveBeenCalled();
   });
 });

package/tests/mocks.ts

@@ -17,7 +17,7 @@ export const createMockServer = (
   const server: Partial<Server> = {
     baseUrl: "http://127.0.0.1:8080",
     models,
-    getApiKey: () => Promise.resolve(overrides.apiKey ?? ""),
+    getApiKey: () => overrides.apiKey ?? "",
     fetchModels: () => mockRpc("/v1/models"),
     fetchModelProps: (modelId: string) =>
       mockRpc(`/props?model=${modelId}&autoload=false`),

package/tests/server.test.ts

@@ -1,4 +1,5 @@
 import { beforeEach, describe, expect, it } from "vitest";
+import { POLLING_TIMEOUT, SERVER_TIMEOUT } from "../src/constants";
 import { ServerStatus } from "../src/enums/serverStatus";
 import { Server } from "../src/server";
 import { createMockServer, mockRpc } from "./mocks";
@@ -146,6 +147,51 @@ describe("Server postRequest", () => {
   });
 });
 
+describe("Server timeouts", () => {
+  it("should use default timeouts when not provided", () => {
+    const server = new Server("http://127.0.0.1:8080");
+
+    expect(server.serverTimeout).toBe(SERVER_TIMEOUT);
+    expect(server.pollingTimeout).toBe(POLLING_TIMEOUT);
+  });
+
+  it("should accept custom serverTimeout", () => {
+    const server = new Server(
+      "http://127.0.0.1:8080",
+      undefined,
+      undefined,
+      3000,
+    );
+
+    expect(server.serverTimeout).toBe(3000);
+  });
+
+  it("should accept custom pollingTimeout", () => {
+    const server = new Server(
+      "http://127.0.0.1:8080",
+      undefined,
+      undefined,
+      1000,
+      120000,
+    );
+
+    expect(server.pollingTimeout).toBe(120000);
+  });
+
+  it("should accept both custom timeouts", () => {
+    const server = new Server(
+      "http://127.0.0.1:8080",
+      "my-id",
+      "My Server",
+      2000,
+      90000,
+    );
+
+    expect(server.serverTimeout).toBe(2000);
+    expect(server.pollingTimeout).toBe(90000);
+  });
+});
+
 describe("Server isReady", () => {
   it("should return READY when health status is ok", async () => {
     mockRpc.mockResolvedValueOnce({ status: "ok" });