pi-llama-cpp 0.11.0 → 0.12.0

package/src/managers/command.ts

@@ -14,7 +14,8 @@ import { Mode } from "../enums/mode";
 import { Status } from "../enums/status";
 import { LlamaSettings } from "../interfaces/settings";
 import { BaseModel } from "../models/baseModel";
-import { ServerListEditor } from "../ui/serverListEditor";
+import { createOverrideSettingsList } from "../ui/overrideSettingsList";
+import { ServerSettingsList } from "../ui/serverSettingsList";
 import { errorMessage } from "../utils/errors";
 import { EventManager } from "./events";
 import { ServerManager } from "./server";
@@ -64,15 +65,20 @@ const ARGUMENT_COMPLETIONS: AutocompleteItem[] = [
     label: "unload",
     description: "Unload all models",
   },
+  {
+    value: "settings",
+    label: "settings",
+    description: "Configure llamaSettings",
+  },
   {
     value: "servers",
     label: "servers",
     description: "Manage llama.cpp server URLs",
   },
   {
-    value: "settings",
-    label: "settings",
-    description: "Configure llamaSettings",
+    value: "overrides",
+    label: "overrides",
+    description: "Manage llama.cpp model overrides",
   },
 ];
 
@@ -96,17 +102,17 @@ const parseMs = (value: string): number =>
  * Builds the `SettingsList` items for `/models settings` from the current
  * (merged) values of the scalar `llamaSettings` fields.
  */
-export const buildSettingsItems = (
+export const buildSettingsItems = async (
   settings: LlamaSettingsManager,
-): SettingItem[] => {
-  const { pollingTimeout, serverTimeout } = settings.resolveTimeouts();
+): Promise<SettingItem[]> => {
+  const { pollingTimeout, serverTimeout } = await settings.resolveTimeouts();
 
   return [
     {
       id: Options.REACT_TO_MODEL_SELECT,
       label: "React to model selection",
       description: "Load the model when you pick it in Pi (immediate)",
-      currentValue: settings.resolveReactToModelSelect() ? "on" : "off",
+      currentValue: (await settings.resolveReactToModelSelect()) ? "on" : "off",
       values: ["on", "off"],
     },
     {
@@ -114,14 +120,14 @@ export const buildSettingsItems = (
       label: "Autoload on message",
       description:
         "Auto-load the selected model when you send a message (immediate)",
-      currentValue: settings.resolveAutoloadOnMessage() ? "on" : "off",
+      currentValue: (await settings.resolveAutoloadOnMessage()) ? "on" : "off",
       values: ["on", "off"],
     },
     {
       id: Options.SORT_BY,
       label: "Sort models by",
       description: "Order of models in /models (next open)",
-      currentValue: settings.resolveSortBy(),
+      currentValue: await settings.resolveSortBy(),
       values: [...SORT_VALUES],
     },
     {
@@ -208,9 +214,17 @@ export class CommandManager {
       return;
     }
 
-    // Servers editor: same — edits are passive until the next provider scan
+    // Servers editor: re-registers providers after editing so changes
+    // (add / remove / URL / id / name) apply immediately
     if (args === "servers") {
-      await this.runServersEditor(ctx);
+      await this.runServersEditor(ctx, pi);
+      return;
+    }
+
+    // Overrides editor: re-registers providers after editing so new
+    // overrides take effect on the next request
+    if (args === "overrides") {
+      await this.runOverridesEditor(ctx, pi);
       return;
     }
 
@@ -223,17 +237,15 @@ export class CommandManager {
     }
 
     if (args === "unload") {
-      await Promise.all(
-        this.serverManager.getAllModels().map((model) => model.unload()),
-      );
+      const models = await this.serverManager.getAllModels();
+      await Promise.all(models.map((model) => model.unload()));
       ctx.ui.notify(`Unloaded all ${PROVIDER_NAME} models`, "info");
       return;
     }
 
     if (args === "info") {
-      const infos = await Promise.all(
-        this.serverManager.getAllModels().map((model) => model.getInfo()),
-      );
+      const models = await this.serverManager.getAllModels();
+      const infos = await Promise.all(models.map((model) => model.getInfo()));
       ctx.ui.notify(ctx.ui.theme.fg("accent", infos.join("\n")), "info");
       return;
     }
@@ -248,7 +260,9 @@ export class CommandManager {
    *
    * Writes go to the global `~/.pi/agent/settings.json` via
    * `LlamaSettingsManager.setLlamaSetting()`; write errors are notified
-   * and leave the dialog open with values unchanged.
+   * and leave the dialog open with values unchanged. These settings
+   * (reactToModelSelect, autoloadOnMessage, sortBy, timeouts) do not
+   * require provider re-registration.
    */
   private async runSettingsMenu(ctx: ExtensionCommandContext): Promise<void> {
     if (ctx.mode !== "tui") {
@@ -259,7 +273,7 @@ export class CommandManager {
       return;
     }
 
-    const items = buildSettingsItems(this.settings);
+    const items = await buildSettingsItems(this.settings);
 
     await ctx.ui.custom<void>(
       (_tui, _theme, _kb, done) =>
@@ -282,16 +296,19 @@ export class CommandManager {
 
   /**
    * Runs the interactive servers editor for `llamaSettings.servers`.
-   * Enter/e edits the selected URL, i its id, n its name, a adds,
-   * d deletes (after a confirmation prompt); Esc closes.
+   * Enter on a server row drills into its field-edit submenu (URL/id/name);
+   * a adds a new server (inline Input), d deletes (after confirmation);
+   * Esc closes.
    *
    * Writes go to the global `~/.pi/agent/settings.json` via
    * `LlamaSettingsManager.setLlamaSetting()`; write errors are notified and
-   * the editor stays open with the pre-mutation list. List changes (add,
-   * remove, URL/`id`/`name` edits) apply the next time providers are
-   * scanned — run `/models` to see them.
+   * the editor stays open with the pre-mutation list. After closing,
+   * providers are re-registered so server changes apply immediately.
    */
-  private async runServersEditor(ctx: ExtensionCommandContext): Promise<void> {
+  private async runServersEditor(
+    ctx: ExtensionCommandContext,
+    pi: ExtensionAPI,
+  ): Promise<void> {
     if (ctx.mode !== "tui") {
       ctx.ui.notify(
         "/models servers requires an interactive session (TUI)",
@@ -300,22 +317,79 @@ export class CommandManager {
       return;
     }
 
-    const servers = this.settings.llamaServers;
+    const servers = await this.settings.getLlamaServers();
 
     await ctx.ui.custom<void>(
       (tui, theme, keybindings, done) =>
-        new ServerListEditor({
+        new ServerSettingsList({
           tui,
           theme,
           keybindings,
           servers,
           persist: (next) => this.settings.setLlamaSetting("servers", next),
-          done: () => done(undefined),
+          done: () => {
+            done(undefined);
+            // Re-register providers so the updated server list takes effect
+            this.serverManager.update(pi);
+          },
           onError: (message) => ctx.ui.notify(message, "error"),
         }),
     );
   }
 
+  /**
+   * Runs the interactive overrides editor for
+   * `llamaSettings.servers[].overrides`: a SettingsList of servers drilling
+   * down into each server's override entries (one row per pattern, with
+   * add/delete support). Within a server's entry list: Enter drills into
+   * the field-edit submenu; a adds, d deletes (after confirmation).
+   *
+   * Fields use a mix of finite (Enter to cycle) and infinite (Enter to
+   * type) editing:
+   *
+   * - Pattern / costs (input, output, cacheRead, cacheWrite): infinite —
+   *   Enter opens an Input for typing.
+   * - Capabilities: finite — Enter cycles between `text` and `text | image`.
+   * - Reasoning: finite — Enter cycles between `true` and `false`.
+   *
+   * Servers themselves are not managed here — use `/models servers`.
+   *
+   * Writes go to the global `~/.pi/agent/settings.json` via
+   * `LlamaSettingsManager.setLlamaSetting()`; write errors are notified and
+   * leave the values unchanged. After closing, providers are
+   * re-registered so new overrides take effect on the next request.
+   */
+  private async runOverridesEditor(
+    ctx: ExtensionCommandContext,
+    pi: ExtensionAPI,
+  ): Promise<void> {
+    if (ctx.mode !== "tui") {
+      ctx.ui.notify(
+        "/models overrides requires an interactive session (TUI)",
+        "warning",
+      );
+      return;
+    }
+
+    const servers = await this.settings.getLlamaServers();
+    await ctx.ui.custom<void>((tui, theme, keybindings, done) =>
+      createOverrideSettingsList({
+        tui,
+        theme,
+        keybindings,
+        servers,
+        persist: (next) => this.settings.setLlamaSetting("servers", next),
+        done: () => {
+          done(undefined);
+          // Re-register providers so the updated overrides take effect
+          this.serverManager.update(pi);
+        },
+        onError: (message) => ctx.ui.notify(message, "error"),
+        onChanged: () => {}, // no per-change notification needed
+      }),
+    );
+  }
+
   /**
    * Notifies the user that a server is unreachable.
    */
@@ -332,7 +406,7 @@ export class CommandManager {
   ): Promise<void> {
     const event = await this.modelSelectionHandler(
       ctx,
-      this.serverManager.getAllModels(),
+      await this.serverManager.getAllModels(),
     );
 
     if (!event) return;
@@ -522,7 +596,10 @@ export class CommandManager {
           : [Action.SWITCH, ...base],
       [Status.LOADING]: [...base],
       [Status.FAILED]: [Action.RETRY, ...base],
-      [Status.SLEEPING]: [Action.SWITCH, Action.UNLOAD, ...base],
+      [Status.SLEEPING]:
+        model.mode === Mode.ROUTER
+          ? [Action.SWITCH, Action.UNLOAD, ...base]
+          : [Action.SWITCH, ...base],
       [Status.UNLOADED]: [Action.LOAD_AND_SWITCH, Action.LOAD, ...base],
       [Status.UNAUTHORIZED]: [...base],
     };

package/src/managers/events.ts

@@ -47,7 +47,7 @@ export class EventManager {
    */
   async onModelSelect(event: ModelSelectEvent, ctx: ExtensionContext) {
     // Check if the model_select event should be used
-    if (!this.settings.resolveReactToModelSelect()) return;
+    if (!(await this.settings.resolveReactToModelSelect())) return;
 
     for (const { providerId, models } of this.serverManager.servers) {
       if (event.model.provider !== providerId) continue;
@@ -72,7 +72,7 @@ export class EventManager {
    * @param model The model to potentially auto-load
    */
   private async autoLoadIfNeeded(model: BaseModel): Promise<void> {
-    if (!this.settings.resolveAutoloadOnMessage()) return;
+    if (!(await this.settings.resolveAutoloadOnMessage())) return;
 
     const status = await model.getStatus();
     if (status !== Status.UNLOADED) return;

package/src/managers/server.ts

@@ -30,7 +30,7 @@ export class ServerManager {
    */
   async initialize(pi: ExtensionAPI) {
     // Register the providers with the configured server timeout
-    const { serverTimeout } = this.settings.resolveTimeouts();
+    const { serverTimeout } = await this.settings.resolveTimeouts();
     await this.update(pi, serverTimeout);
   }
 
@@ -51,7 +51,7 @@ export class ServerManager {
     // (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 this.settings.resolveServers()) {
+    for (const server of await this.settings.resolveServers()) {
       if (seen.has(server.providerId)) continue;
       seen.add(server.providerId);
       fresh.push(server);
@@ -171,16 +171,20 @@ export class ServerManager {
 
   /**
    * 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 sortBy = this.settings.resolveSortBy();
-    const allModels = this.servers.flatMap((s) => s.models);
+  async getAllModels(): Promise<BaseModel[]> {
+    const sortBy = await this.settings.resolveSortBy();
 
-    if (sortBy === "api") return allModels;
+    if (sortBy === "api") {
+      return this.servers.flatMap((s) => s.models);
+    }
 
-    return allModels.sort(ServerManager.SORTERS[sortBy]);
+    const sorter = ServerManager.SORTERS[sortBy];
+    return this.servers.flatMap((s) => [...s.models].sort(sorter));
   }
 
   private static sortByIdAsc(a: BaseModel, b: BaseModel): number {
@@ -204,8 +208,7 @@ export class ServerManager {
   }
 
   /**
-   * Comparators for each sort mode except "api", which preserves server
-   * order (short-circuited in {@link ServerManager.getAllModels}).
+   * Comparators for sorting models within each server.
    */
   private static readonly SORTERS: Record<
     Exclude<SortBy, "api">,

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,
@@ -15,7 +18,11 @@ import {
   THINKING_BUDGETS,
   type SortBy,
 } from "../constants";
-import { LlamaServer, LlamaSettings } from "../interfaces/settings";
+import {
+  LlamaServer,
+  LlamaSettings,
+  ModelOverride,
+} from "../interfaces/settings";
 import { Server } from "../server";
 import { SettingsStore } from "../utils/settingsStore";
 import { isValidServerUrl, normalizeUrl } from "../utils/urls";
@@ -23,7 +30,22 @@ import { isValidServerUrl, normalizeUrl } from "../utils/urls";
 export class LlamaSettingsManager {
   private settingsManager = SettingsManager.create(process.cwd());
 
-  constructor(private readonly store: SettingsStore = new SettingsStore()) {}
+  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[] = [];
@@ -38,29 +60,31 @@ export class LlamaSettingsManager {
   }
 
   /**
-   * Convenience getter for merged project/global settings
+   * Reloads settings from disk and returns merged project/global settings.
+   * Project settings override global settings.
    */
-  private get mergedSettings(): Record<string, any> {
-    const merged = {
+  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 getter for the merged `servers` list (project overrides
-   * global, per-key merge)
+   * Convenience method for the merged `servers` list (project overrides
+   * global, per-key merge). Reloads settings from disk before reading.
    */
-  get llamaServers(): LlamaServer[] {
-    return this.llamaSettings.servers ?? [];
+  async getLlamaServers(): Promise<LlamaServer[]> {
+    return (await this.getLlamaSettings()).servers ?? [];
   }
 
   /**
@@ -73,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];
@@ -101,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);
@@ -147,26 +173,53 @@ export class LlamaSettingsManager {
       });
   }
 
+  /**
+   * 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 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(this, {
-        baseUrl: url,
-        customId: config?.id,
-        customName: config?.name,
-      });
-    });
+      const overrides = await this.resolveServerOverrides(url);
+      servers.push(
+        new Server(this, {
+          baseUrl: url,
+          customId: config?.id,
+          customName: config?.name,
+          overrides,
+        }),
+      );
+    }
+    return servers;
   }
 
   /**
@@ -206,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
+    );
   }
 
   /**
@@ -215,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
+    );
   }
 
   /**
@@ -224,10 +282,14 @@ 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,
     };
   }
 
@@ -236,13 +298,16 @@ export class LlamaSettingsManager {
    *
    * @returns The sort order: "asc", "desc", "asc-name", "desc-name", or "api"
    */
-  resolveSortBy(): SortBy {
-    return this.llamaSettings.sortBy ?? SORT_BY;
+  async resolveSortBy(): Promise<SortBy> {
+    return (await this.getLlamaSettings()).sortBy ?? SORT_BY;
   }
 
   /**
-   * Persists one llamaSettings field to the global settings file and
-   * reloads the in-memory settings so resolvers see the change immediately.
+   * 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).
@@ -250,8 +315,18 @@ export class LlamaSettingsManager {
   async setLlamaSetting<K extends keyof LlamaSettings>(
     key: K,
     value: LlamaSettings[K],
+    scope: "auto" | "global" | "project" = "auto",
   ): Promise<void> {
-    await this.store.updateKey(SETTINGS_KEY, (current) => {
+    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>)