pi-llama-cpp 0.10.0 → 0.12.0

package/src/managers/server.ts

@@ -1,15 +1,27 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { API_TYPE, PROVIDER_NAME } from "../constants";
+import { API_TYPE, PROVIDER_NAME, type SortBy } from "../constants";
 import { ServerStatus } from "../enums/serverStatus";
 import { BaseModel } from "../models/baseModel";
 import { Server } from "../server";
-import { settings } from "./settings";
+import type { LlamaSettingsManager } from "./settings";
+
+/** Model-list comparator: negative if a sorts first, positive if b does. */
+type ModelComparator = (a: BaseModel, b: BaseModel) => number;
 
 export class ServerManager {
+  constructor(private readonly settings: LlamaSettingsManager) {}
   readonly failedUrls: string[] = [];
   private readonly warnings: string[] = [];
+  private readonly serverList: Server[] = [];
 
-  constructor(private readonly servers: Server[]) {}
+  /**
+   * Live view of the server list. `update()` re-derives the list from
+   * settings on every scan (in place), so `/models servers` edits apply
+   * without a restart.
+   */
+  get servers(): readonly Server[] {
+    return this.serverList;
+  }
 
   /**
    * Verifies reachability of servers and registers the providers
@@ -18,7 +30,7 @@ export class ServerManager {
    */
   async initialize(pi: ExtensionAPI) {
     // Register the providers with the configured server timeout
-    const { serverTimeout } = settings.resolveTimeouts();
+    const { serverTimeout } = await this.settings.resolveTimeouts();
     await this.update(pi, serverTimeout);
   }
 
@@ -32,6 +44,33 @@ export class ServerManager {
   async update(pi: ExtensionAPI, timeout?: number) {
     this.failedUrls.length = 0;
 
+    // Surface warnings from strict URL parsing (dropped invalid entries)
+    this.warnings.push(...this.settings.takeWarnings());
+
+    // Re-derive the server list from settings so `/models servers` edits
+    // (add / remove / URL / id / name) apply on the next scan
+    const fresh: Server[] = [];
+    const seen = new Set<string>(); // dedupe repeated URLs (same providerId)
+    for (const server of await this.settings.resolveServers()) {
+      if (seen.has(server.providerId)) continue;
+      seen.add(server.providerId);
+      fresh.push(server);
+    }
+
+    // Unregister providers that disappeared (removed or edited away);
+    // no-op for providers that were never registered
+    for (const old of this.servers) {
+      if (fresh.some((f) => f.providerId === old.providerId)) continue;
+      pi.unregisterProvider(old.providerId);
+      // Optional chain is intentional despite the non-optional type: `sse`
+      // is undefined until initialize() runs (async-constructor hack — see Server)
+      old.sseManager?.disconnect();
+    }
+
+    // Replace in place so the live `servers` view stays valid (D1)
+    this.serverList.length = 0;
+    this.serverList.push(...fresh);
+
     const registrableServers = timeout
       ? await this.findRegistrableServers(timeout)
       : this.servers;
@@ -95,7 +134,7 @@ export class ServerManager {
    */
   private async registerProvider(server: Server, pi: ExtensionAPI) {
     const { baseUrl, models, providerId, providerName } = server;
-    const apiKey = await server.getApiKey();
+    const apiKey = server.getApiKey();
     const modelConfigs = await Promise.all(
       models.map((m) => m.toProviderConfig()),
     );
@@ -123,26 +162,61 @@ export class ServerManager {
    * Returns the server for a given model.
    *
    * @param model - The model to find the server for
-   * @returns The server containing the model
+   * @returns The server containing the model, or `undefined` when no
+   * current server matches (e.g. removed while a model was loading)
    */
-  getServer(model: BaseModel): Server {
-    return this.servers.find((s) => s.baseUrl === model.serverUrl)!;
+  getServer(model: BaseModel): Server | undefined {
+    return this.servers.find((s) => s.baseUrl === model.serverUrl);
   }
 
   /**
-   * Returns all models from all servers.
+   * Returns all models from all servers, sorted by the configured sort mode.
+   * Servers maintain their order from `llamaSettings`; sorting only applies
+   * to models within each server.
    *
    * @returns Flat array of all models across all servers
    */
-  getAllModels(): BaseModel[] {
-    const response = [];
+  async getAllModels(): Promise<BaseModel[]> {
+    const sortBy = await this.settings.resolveSortBy();
 
-    for (const { models } of this.servers) {
-      for (const model of models) {
-        response.push(model);
-      }
+    if (sortBy === "api") {
+      return this.servers.flatMap((s) => s.models);
     }
 
-    return response;
+    const sorter = ServerManager.SORTERS[sortBy];
+    return this.servers.flatMap((s) => [...s.models].sort(sorter));
   }
+
+  private static sortByIdAsc(a: BaseModel, b: BaseModel): number {
+    return a.id.localeCompare(b.id);
+  }
+
+  private static sortByIdDesc(a: BaseModel, b: BaseModel): number {
+    return b.id.localeCompare(a.id);
+  }
+
+  /** Name ascending, with ID as tiebreaker. */
+  private static sortByNameAsc(a: BaseModel, b: BaseModel): number {
+    const cmp = a.name.localeCompare(b.name);
+    return cmp !== 0 ? cmp : a.id.localeCompare(b.id);
+  }
+
+  /** Name descending, with ID as tiebreaker. */
+  private static sortByNameDesc(a: BaseModel, b: BaseModel): number {
+    const cmp = b.name.localeCompare(a.name);
+    return cmp !== 0 ? cmp : a.id.localeCompare(b.id);
+  }
+
+  /**
+   * Comparators for sorting models within each server.
+   */
+  private static readonly SORTERS: Record<
+    Exclude<SortBy, "api">,
+    ModelComparator
+  > = {
+    asc: ServerManager.sortByIdAsc,
+    desc: ServerManager.sortByIdDesc,
+    "asc-name": ServerManager.sortByNameAsc,
+    "desc-name": ServerManager.sortByNameDesc,
+  };
 }

package/src/managers/settings.ts

@@ -1,8 +1,11 @@
 import { ApiKeyCredential, ModelThinkingLevel } from "@earendil-works/pi-ai";
 import {
+  getAgentDir,
   readStoredCredential,
   SettingsManager,
 } from "@earendil-works/pi-coding-agent";
+import { access } from "node:fs/promises";
+import { join } from "node:path";
 import {
   API_KEY_PLACEHOLDER,
   AUTOLOAD_ON_MESSAGE,
@@ -10,32 +13,78 @@ import {
   POLLING_TIMEOUT,
   REACT_TO_MODEL_SELECT,
   SERVER_TIMEOUT,
+  SETTINGS_KEY,
+  SORT_BY,
   THINKING_BUDGETS,
+  type SortBy,
 } from "../constants";
-import { LlamaSettings } from "../interfaces/settings";
+import {
+  LlamaServer,
+  LlamaSettings,
+  ModelOverride,
+} from "../interfaces/settings";
 import { Server } from "../server";
-
-const SETTINGS_KEY = "llamaSettings";
+import { SettingsStore } from "../utils/settingsStore";
+import { isValidServerUrl, normalizeUrl } from "../utils/urls";
 
 export class LlamaSettingsManager {
   private settingsManager = SettingsManager.create(process.cwd());
 
+  private globalStore = new SettingsStore(join(getAgentDir(), "settings.json"));
+  private projectStore = new SettingsStore(
+    join(process.cwd(), ".pi", "settings.json"),
+  );
+
+  /**
+   * Check if project settings file exists in the current working directory.
+   */
+  private async hasProjectSettings(): Promise<boolean> {
+    try {
+      await access(join(process.cwd(), ".pi", "settings.json"));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /** Warnings collected during URL resolution (dropped invalid entries). */
+  private warnings: string[] = [];
+
   /**
-   * Convenience getter for merged project/global settings
+   * Returns and clears warnings collected during URL resolution.
    */
-  private get mergedSettings(): Record<string, any> {
-    const merged = {
+  takeWarnings(): string[] {
+    const warnings = [...this.warnings];
+    this.warnings.length = 0;
+    return warnings;
+  }
+
+  /**
+   * Reloads settings from disk and returns merged project/global settings.
+   * Project settings override global settings.
+   */
+  private async getMergedSettings(): Promise<Record<string, any>> {
+    await this.settingsManager.reload();
+    return {
       ...this.settingsManager.getGlobalSettings(),
       ...this.settingsManager.getProjectSettings(),
     } as Record<string, any>;
-    return merged;
   }
 
   /**
-   * Convenience getter for the `llamaSettings` key
+   * Convenience method for the `llamaSettings` key.
+   * Reloads settings from disk before reading.
    */
-  private get llamaSettings(): LlamaSettings {
-    return this.mergedSettings[SETTINGS_KEY] ?? {};
+  async getLlamaSettings(): Promise<LlamaSettings> {
+    return (await this.getMergedSettings())[SETTINGS_KEY] ?? {};
+  }
+
+  /**
+   * Convenience method for the merged `servers` list (project overrides
+   * global, per-key merge). Reloads settings from disk before reading.
+   */
+  async getLlamaServers(): Promise<LlamaServer[]> {
+    return (await this.getLlamaSettings()).servers ?? [];
   }
 
   /**
@@ -48,14 +97,14 @@ export class LlamaSettingsManager {
    *
    * @returns The list of URLs to use
    */
-  resolveUrls(): string[] {
+  async resolveUrls(): Promise<string[]> {
     let response = this.resolveEnvUrls();
     if (response.length > 0) return response;
 
-    response = this.resolveServerUrls();
+    response = await this.resolveServerUrls();
     if (response.length > 0) return response;
 
-    response = this.resolveLegacyUrls();
+    response = await this.resolveLegacyUrls();
     if (response.length > 0) return response;
 
     return [LLAMA_SERVER_URL];
@@ -76,22 +125,24 @@ export class LlamaSettingsManager {
   /**
    * Resolves the llama-server URLs from `llamaSettings.servers`.
    * Settings are merged, prioritizing project over global settings.
+   * Reloads settings from disk before reading.
    *
    * @returns A list of detected URLs
    */
-  private resolveServerUrls(): string[] {
-    const { servers = [] } = this.llamaSettings;
+  private async resolveServerUrls(): Promise<string[]> {
+    const { servers = [] } = await this.getLlamaSettings();
     return servers.map((s) => this.parseUrls(s.url)).flat();
   }
 
   /**
-   * Resolves the llama-server URLs from `llamaSettings.servers`.
+   * Resolves the llama-server URLs from `llamaServerUrl` legacy key.
    * Settings are merged, prioritizing project over global settings.
+   * Reloads settings from disk before reading.
    *
    * @returns A list of detected URLs
    */
-  private resolveLegacyUrls(): string[] {
-    const { llamaServerUrl = null } = this.mergedSettings;
+  private async resolveLegacyUrls(): Promise<string[]> {
+    const { llamaServerUrl = null } = await this.getMergedSettings();
     if (!llamaServerUrl) return [];
 
     return this.parseUrls(llamaServerUrl);
@@ -99,42 +150,76 @@ export class LlamaSettingsManager {
 
   /**
    * Parses a raw URL string into an array of cleaned URLs.
-   * Splits on semicolons, trims whitespace, filters empty strings,
-   * and strips trailing slashes.
+   * Splits on semicolons, trims whitespace, filters empty strings, strips
+   * trailing slashes, and drops entries without an http(s) scheme —
+   * collecting a warning for each dropped entry (same validation the
+   * `/models servers` editor applies).
    *
    * @returns A sanitized URL
    */
   private parseUrls(raw: string): string[] {
     return raw
       .split(";")
-      .map((u) => u.trim())
-      .filter((u) => u.length > 0)
-      .map((u) => u.replace(/\/+$/, ""));
+      .map(normalizeUrl)
+      .filter((u) => {
+        if (u.length === 0) return false;
+        if (!isValidServerUrl(u)) {
+          this.warnings.push(
+            `Ignoring invalid server URL '${u}' (needs http(s)://)`,
+          );
+          return false;
+        }
+        return true;
+      });
+  }
+
+  /**
+   * Resolves the override map for a given server URL.
+   *
+   * Reads the `overrides` field from the matching server config and returns
+   * a map of model ID → override. Returns an empty object when the server
+   * has no `overrides` defined.
+   *
+   * @param serverUrl - The URL of the server to resolve overrides for
+   * @returns A map of model ID to override configuration (partial fields,
+   *          fallbacks applied at consumption time)
+   */
+  async resolveServerOverrides(
+    serverUrl: string,
+  ): Promise<Record<string, ModelOverride>> {
+    const serverConfig = (await this.getLlamaSettings()).servers?.find(
+      (s: { url: string }) => s.url === serverUrl,
+    );
+    return serverConfig?.overrides ?? {};
   }
 
   /**
    * Resolves the servers that this extension will use.
    * Uses `resolveUrls()` as the source of truth for URLs (env > settings >
-   * legacy > default), then applies `id`/`name` from `llamaSettings.servers`
-   * as overrides when available.
+   * legacy > default), then applies `id`/`name`/`overrides` from
+   * `llamaSettings.servers` as overrides when available.
+   * Reloads settings from disk before reading.
    *
    * @returns A list of Server objects
    */
-  resolveServers(): Server[] {
-    const { pollingTimeout, serverTimeout } = this.resolveTimeouts();
-    const urls = this.resolveUrls();
-    const serverConfigs = this.llamaSettings.servers ?? [];
+  async resolveServers(): Promise<Server[]> {
+    const urls = await this.resolveUrls();
+    const serverConfigs = (await this.getLlamaSettings()).servers ?? [];
 
-    return urls.map((url) => {
+    const servers: Server[] = [];
+    for (const url of urls) {
       const config = serverConfigs.find((s) => s.url === url);
-      return new Server(
-        url,
-        config?.id,
-        config?.name,
-        serverTimeout,
-        pollingTimeout,
+      const overrides = await this.resolveServerOverrides(url);
+      servers.push(
+        new Server(this, {
+          baseUrl: url,
+          customId: config?.id,
+          customName: config?.name,
+          overrides,
+        }),
       );
-    });
+    }
+    return servers;
   }
 
   /**
@@ -174,8 +259,11 @@ export class LlamaSettingsManager {
    *
    * @returns `true` if the extension should load the model on model_select
    */
-  resolveReactToModelSelect(): boolean {
-    return this.llamaSettings.reactToModelSelect ?? REACT_TO_MODEL_SELECT;
+  async resolveReactToModelSelect(): Promise<boolean> {
+    return (
+      (await this.getLlamaSettings()).reactToModelSelect ??
+      REACT_TO_MODEL_SELECT
+    );
   }
 
   /**
@@ -183,8 +271,10 @@ export class LlamaSettingsManager {
    *
    * @returns `true` if the extension should auto-load models
    */
-  resolveAutoloadOnMessage(): boolean {
-    return this.llamaSettings.autoloadOnMessage ?? AUTOLOAD_ON_MESSAGE;
+  async resolveAutoloadOnMessage(): Promise<boolean> {
+    return (
+      (await this.getLlamaSettings()).autoloadOnMessage ?? AUTOLOAD_ON_MESSAGE
+    );
   }
 
   /**
@@ -192,12 +282,59 @@ export class LlamaSettingsManager {
    *
    * @returns Object with polling and server timeout values
    */
-  resolveTimeouts(): { pollingTimeout: number; serverTimeout: number } {
+  async resolveTimeouts(): Promise<{
+    pollingTimeout: number;
+    serverTimeout: number;
+  }> {
+    const llamaSettings = await this.getLlamaSettings();
     return {
-      pollingTimeout: this.llamaSettings.pollingTimeout ?? POLLING_TIMEOUT,
-      serverTimeout: this.llamaSettings.serverTimeout ?? SERVER_TIMEOUT,
+      pollingTimeout: llamaSettings.pollingTimeout ?? POLLING_TIMEOUT,
+      serverTimeout: llamaSettings.serverTimeout ?? SERVER_TIMEOUT,
     };
   }
+
+  /**
+   * Resolves the sort order for model lists.
+   *
+   * @returns The sort order: "asc", "desc", "asc-name", "desc-name", or "api"
+   */
+  async resolveSortBy(): Promise<SortBy> {
+    return (await this.getLlamaSettings()).sortBy ?? SORT_BY;
+  }
+
+  /**
+   * Persists one llamaSettings field to settings and reloads the in-memory
+   * settings so resolvers see the change immediately.
+   *
+   * When `scope` is `"auto"` (default), writes to the project `.pi/settings.json`
+   * if it exists, otherwise to global `~/.pi/agent/settings.json`.
+   *
+   * Rejects if the file can't be read (e.g. invalid JSON) or written —
+   * in-memory state stays consistent (reload only on success).
+   */
+  async setLlamaSetting<K extends keyof LlamaSettings>(
+    key: K,
+    value: LlamaSettings[K],
+    scope: "auto" | "global" | "project" = "auto",
+  ): Promise<void> {
+    const store =
+      scope === "auto"
+        ? (await this.hasProjectSettings())
+          ? this.projectStore
+          : this.globalStore
+        : scope === "project"
+          ? this.projectStore
+          : this.globalStore;
+
+    await store.updateKey(SETTINGS_KEY, (current) => {
+      const merged =
+        typeof current === "object" && current !== null
+          ? (current as Record<string, unknown>)
+          : {};
+      return { ...merged, [key]: value };
+    });
+    await this.settingsManager.reload();
+  }
 }
 
 /**

package/src/models/baseModel.ts

@@ -1,3 +1,4 @@
+import type { ModelCost } from "@earendil-works/pi-ai";
 import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
 import { FALLBACK_CTX, POLLING_INTERVAL } from "../constants";
 import { Mode } from "../enums/mode";
@@ -16,14 +17,6 @@ export abstract class BaseModel {
     protected readonly server: Server,
   ) {}
 
-  protected readonly statusMapper: Record<string, Status> = {
-    loaded: Status.LOADED,
-    loading: Status.LOADING,
-    failed: Status.FAILED,
-    sleeping: Status.SLEEPING,
-    unloaded: Status.UNLOADED,
-  };
-
   protected readonly labelIcons: Record<Status, string> = {
     [Status.LOADED]: "🟢",
     [Status.LOADING]: "🟡",
@@ -65,18 +58,24 @@ export abstract class BaseModel {
 
   /**
    * Whether the model is a reasoning model.
-   * Currently always returns true since there's no way to detect this from llama-server.
+   * An override's `reasoning` wins; otherwise defaults to `true`, since
+   * there's no way to detect this from llama-server.
    */
   get reasoning(): boolean {
-    return true;
+    return this.server.findOverrideForModel(this.id)?.reasoning ?? true;
   }
 
   /**
-   * Detects the capabilities of the model
+   * Detects the capabilities of the model.
+   * An override's `capabilities` fully replaces detection; otherwise the
+   * model's modalities are probed from the server.
    *
    * @returns An array of capabilities, as expected by Pi
    */
   async getCapabilities(): Promise<("text" | "image")[]> {
+    const overridden = this.server.findOverrideForModel(this.id)?.capabilities;
+    if (overridden) return overridden;
+
     try {
       // When loaded, this works alright
       const { modalities } = await this.server.fetchModelProps(this.id);
@@ -123,9 +122,16 @@ export abstract class BaseModel {
   /**
    * Gets the context size of a particular model.
    *
+   * An override's `contextSize` (when set and `> 0`) replaces detection;
+   * otherwise the value is autodetected from the server, falling back to
+   * {@link FALLBACK_CTX}. A stored `0` behaves as if the key were absent.
+   *
    * @returns The context size in tokens
    */
   async getContextSize(): Promise<number> {
+    const overridden = this.server.findOverrideForModel(this.id)?.contextSize;
+    if (overridden && overridden > 0) return overridden;
+
     try {
       const { data } = await this.server.fetchModels();
       const { n_ctx } = data.find((m) => m.id === this.id)?.meta!;
@@ -170,7 +176,18 @@ export abstract class BaseModel {
    * @returns A Pi configuration object
    */
   async toProviderConfig(): Promise<ProviderModelConfig> {
-    const response = {
+    const override = this.server.findOverrideForModel(this.id) ?? {};
+
+    // Merge the matched override's cost with zero defaults
+    const userCost = override.cost ?? {};
+    const cost: ModelCost = {
+      input: userCost.input ?? 0,
+      output: userCost.output ?? 0,
+      cacheRead: userCost.cacheRead ?? 0,
+      cacheWrite: userCost.cacheWrite ?? 0,
+    };
+
+    const response: ProviderModelConfig = {
       id: this.id,
       name: this.name,
       reasoning: this.reasoning,
@@ -184,10 +201,15 @@ export abstract class BaseModel {
       },
       input: await this.getCapabilities(),
       contextWindow: await this.getContextSize(),
-      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-      maxTokens: await this.getContextSize(),
+      cost,
+      maxTokens: override.maxTokens ?? (await this.getContextSize()),
     };
 
+    // Add compat if the override specifies it
+    if (override.compat) {
+      response.compat = override.compat;
+    }
+
     return response;
   }
 
@@ -253,7 +275,7 @@ export abstract class BaseModel {
     interval: number = POLLING_INTERVAL,
   ): Promise<void> {
     if (timeout === undefined) {
-      timeout = this.server.pollingTimeout;
+      timeout = await this.server.getPollingTimeout();
     }
     while ((await this.getStatus()) === Status.LOADING) {
       // Force a timeout if we wasted too much time polling

package/src/models/routerModel.ts

@@ -41,7 +41,8 @@ export class RouterModel extends BaseModel {
       }
     }
 
-    const timeout = this.server.pollingTimeout - elapsed;
+    const pollingTimeout = await this.server.getPollingTimeout();
+    const timeout = pollingTimeout - elapsed;
     return await super.pollStatus(startTime, timeout);
   }