pi-llama-cpp 0.10.0 → 0.11.0

package/src/managers/command.ts

@@ -1,18 +1,180 @@
-import type {
-  ExtensionAPI,
-  ExtensionCommandContext,
+import {
+  getSettingsListTheme,
+  type ExtensionAPI,
+  type ExtensionCommandContext,
 } from "@earendil-works/pi-coding-agent";
-import { AutocompleteItem } from "@earendil-works/pi-tui";
+import {
+  AutocompleteItem,
+  SettingsList,
+  type SettingItem,
+} from "@earendil-works/pi-tui";
 import { PROVIDER_NAME } from "../constants";
 import { Action } from "../enums/action";
 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 { errorMessage } from "../utils/errors";
 import { EventManager } from "./events";
 import { ServerManager } from "./server";
+import type { LlamaSettingsManager } from "./settings";
+
+/**
+ * Identifiers of the editable fields shown in `/models settings`.
+ * Values match the scalar `LlamaSettings` keys.
+ */
+export enum Options {
+  REACT_TO_MODEL_SELECT = "reactToModelSelect",
+  AUTOLOAD_ON_MESSAGE = "autoloadOnMessage",
+  SORT_BY = "sortBy",
+  POLLING_TIMEOUT = "pollingTimeout",
+  SERVER_TIMEOUT = "serverTimeout",
+}
+
+type SortByValue = NonNullable<LlamaSettings["sortBy"]>;
+
+const SORT_VALUES: SortByValue[] = [
+  "asc",
+  "desc",
+  "asc-name",
+  "desc-name",
+  "api",
+];
+
+/** Presets (ms) for `pollingTimeout` */
+const POLLING_PRESETS = [15000, 30000, 60000, 120000, 300000];
+
+/** Presets (ms) for `serverTimeout` */
+const SERVER_PRESETS = [500, 1000, 2000, 5000, 10000];
+
+/**
+ * `/models` subcommand completions. Module-level so
+ * {@link CommandManager.getArgumentCompletions} doesn't rebuild the
+ * table on every keystroke.
+ */
+const ARGUMENT_COMPLETIONS: AutocompleteItem[] = [
+  {
+    value: "info",
+    label: "info",
+    description: "Show information of all models",
+  },
+  {
+    value: "unload",
+    label: "unload",
+    description: "Unload all models",
+  },
+  {
+    value: "servers",
+    label: "servers",
+    description: "Manage llama.cpp server URLs",
+  },
+  {
+    value: "settings",
+    label: "settings",
+    description: "Configure llamaSettings",
+  },
+];
+
+/**
+ * Formats milliseconds compactly for display (e.g. `500 -> "500ms"`,
+ * `60000 -> "60s"`).
+ */
+export const formatMs = (ms: number): string =>
+  ms % 1000 === 0 ? `${ms / 1000}s` : `${ms}ms`;
+
+/**
+ * Parses a value produced by `formatMs()` back to milliseconds.
+ * Only ever called with values from the preset lists.
+ */
+const parseMs = (value: string): number =>
+  value.endsWith("ms")
+    ? Number(value.slice(0, -2))
+    : Number(value.slice(0, -1)) * 1000;
+
+/**
+ * Builds the `SettingsList` items for `/models settings` from the current
+ * (merged) values of the scalar `llamaSettings` fields.
+ */
+export const buildSettingsItems = (
+  settings: LlamaSettingsManager,
+): SettingItem[] => {
+  const { pollingTimeout, serverTimeout } = 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",
+      values: ["on", "off"],
+    },
+    {
+      id: Options.AUTOLOAD_ON_MESSAGE,
+      label: "Autoload on message",
+      description:
+        "Auto-load the selected model when you send a message (immediate)",
+      currentValue: 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(),
+      values: [...SORT_VALUES],
+    },
+    {
+      id: Options.POLLING_TIMEOUT,
+      label: "Polling timeout",
+      description: "Max model-load wait (next model load)",
+      currentValue: formatMs(pollingTimeout),
+      values: POLLING_PRESETS.map(formatMs),
+    },
+    {
+      id: Options.SERVER_TIMEOUT,
+      label: "Server timeout",
+      description: "Health check / SSE probe timeout (next model load)",
+      currentValue: formatMs(serverTimeout),
+      values: SERVER_PRESETS.map(formatMs),
+    },
+  ];
+};
+
+/**
+ * Persists a change made in the settings menu.
+ * Maps the `SettingsList` id/value pair to the matching `llamaSettings`
+ * key and writes it via `LlamaSettingsManager.setLlamaSetting()`.
+ */
+export const applySettingChange = async (
+  id: string,
+  newValue: string,
+  settings: LlamaSettingsManager,
+): Promise<void> => {
+  switch (id) {
+    case Options.REACT_TO_MODEL_SELECT:
+      await settings.setLlamaSetting("reactToModelSelect", newValue === "on");
+      return;
+    case Options.AUTOLOAD_ON_MESSAGE:
+      await settings.setLlamaSetting("autoloadOnMessage", newValue === "on");
+      return;
+    case Options.SORT_BY:
+      await settings.setLlamaSetting("sortBy", newValue as SortByValue);
+      return;
+    case Options.POLLING_TIMEOUT:
+      await settings.setLlamaSetting("pollingTimeout", parseMs(newValue));
+      return;
+    case Options.SERVER_TIMEOUT:
+      await settings.setLlamaSetting("serverTimeout", parseMs(newValue));
+      return;
+  }
+};
 
 export class CommandManager {
-  constructor(private readonly serverManager: ServerManager) {}
+  constructor(
+    private readonly serverManager: ServerManager,
+    private readonly settings: LlamaSettingsManager,
+  ) {}
 
   /**
    * Sets up the argument completions for the `/models` command
@@ -21,19 +183,9 @@ export class CommandManager {
    * @returns Completions with that prefix
    */
   getArgumentCompletions(prefix: string): AutocompleteItem[] | null {
-    const available = [
-      {
-        value: "info",
-        label: "info",
-        description: "Show information of all models",
-      },
-      {
-        value: "unload",
-        label: "unload",
-        description: "Unload all models",
-      },
-    ];
-    const filtered = available.filter((a) => a.value.startsWith(prefix));
+    const filtered = ARGUMENT_COMPLETIONS.filter((a) =>
+      a.value.startsWith(prefix),
+    );
     return filtered.length > 0 ? filtered : null;
   }
 
@@ -49,6 +201,19 @@ export class CommandManager {
     ctx: ExtensionCommandContext,
     pi: ExtensionAPI,
   ) {
+    // Settings menu: no network round-trip needed, handle before any
+    // server updates / unreachable-server notifications
+    if (args === "settings") {
+      await this.runSettingsMenu(ctx);
+      return;
+    }
+
+    // Servers editor: same — edits are passive until the next provider scan
+    if (args === "servers") {
+      await this.runServersEditor(ctx);
+      return;
+    }
+
     // Re-register providers so Pi sees updated model states
     await this.serverManager.update(pi);
 
@@ -77,6 +242,80 @@ export class CommandManager {
     await this.runModelsMenu(ctx, pi);
   }
 
+  /**
+   * Runs the interactive settings menu for the scalar `llamaSettings`
+   * fields. Enter/Space cycles the value under the cursor; Esc closes.
+   *
+   * Writes go to the global `~/.pi/agent/settings.json` via
+   * `LlamaSettingsManager.setLlamaSetting()`; write errors are notified
+   * and leave the dialog open with values unchanged.
+   */
+  private async runSettingsMenu(ctx: ExtensionCommandContext): Promise<void> {
+    if (ctx.mode !== "tui") {
+      ctx.ui.notify(
+        "/models settings requires an interactive session (TUI)",
+        "warning",
+      );
+      return;
+    }
+
+    const items = buildSettingsItems(this.settings);
+
+    await ctx.ui.custom<void>(
+      (_tui, _theme, _kb, done) =>
+        new SettingsList(
+          items,
+          Math.min(items.length + 2, 15),
+          getSettingsListTheme(),
+          (id, newValue) => {
+            applySettingChange(id, newValue, this.settings).catch(
+              (err: unknown) => {
+                const message = errorMessage(err);
+                ctx.ui.notify(message, "error");
+              },
+            );
+          },
+          () => done(undefined),
+        ),
+    );
+  }
+
+  /**
+   * 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.
+   *
+   * 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.
+   */
+  private async runServersEditor(ctx: ExtensionCommandContext): Promise<void> {
+    if (ctx.mode !== "tui") {
+      ctx.ui.notify(
+        "/models servers requires an interactive session (TUI)",
+        "warning",
+      );
+      return;
+    }
+
+    const servers = this.settings.llamaServers;
+
+    await ctx.ui.custom<void>(
+      (tui, theme, keybindings, done) =>
+        new ServerListEditor({
+          tui,
+          theme,
+          keybindings,
+          servers,
+          persist: (next) => this.settings.setLlamaSetting("servers", next),
+          done: () => done(undefined),
+          onError: (message) => ctx.ui.notify(message, "error"),
+        }),
+    );
+  }
+
   /**
    * Notifies the user that a server is unreachable.
    */
@@ -132,18 +371,24 @@ export class CommandManager {
     const loadActions = [Action.LOAD, Action.LOAD_AND_SWITCH, Action.RETRY];
     if (loadActions.includes(action)) {
       ctx.ui.notify(`Loading ${model.name}...`, "info");
+      // Mark the load as in-flight so session_before_switch can warn about
+      // it (see EventManager.inflightModel for the coupling rationale)
       EventManager.inflightModel = model;
 
-      // Subscribe to progress events
-      const cleanupProgress = this.serverManager
-        .getServer(model)
-        .sseManager.subscribeToProgress(model.id, (percentage, stage) => {
-          const stageText = stage ? ` (${stage})` : "";
-          ctx.ui.notify(
-            `Loading ${model.name}... [${percentage}%${stageText}]`,
-            "info",
-          );
-        });
+      // Subscribe to progress events; skip when the server is gone
+      // (removed/edited away mid-load → getServer returns undefined)
+      const server = this.serverManager.getServer(model);
+      const cleanupProgress =
+        server?.sseManager.subscribeToProgress(
+          model.id,
+          (percentage, stage) => {
+            const stageText = stage ? ` (${stage})` : "";
+            ctx.ui.notify(
+              `Loading ${model.name}... [${percentage}%${stageText}]`,
+              "info",
+            );
+          },
+        ) ?? (() => {});
 
       const onSuccess = async () => {
         const { serverId } = model;
@@ -168,7 +413,7 @@ export class CommandManager {
       };
 
       const onFailure = (err: any) => {
-        const message = err instanceof Error ? err.message : String(err);
+        const message = errorMessage(err);
 
         try {
           ctx.ui.notify(message, "error");
@@ -268,25 +513,22 @@ export class CommandManager {
    * @returns A mapping of actions for each status
    */
   private async getActionsForModel(model: BaseModel): Promise<Array<Action>> {
-    const allActions: Record<Status, Array<Action>> = {
+    const base = [Action.INFO, Action.CANCEL];
+
+    const actions: Record<Status, Array<Action>> = {
       [Status.LOADED]:
         model.mode === Mode.ROUTER
-          ? [Action.SWITCH, Action.UNLOAD, Action.INFO, Action.CANCEL]
-          : [Action.SWITCH, Action.INFO, Action.CANCEL],
-      [Status.LOADING]: [Action.INFO, Action.CANCEL],
-      [Status.FAILED]: [Action.RETRY, Action.CANCEL],
-      [Status.SLEEPING]: [
-        Action.SWITCH,
-        Action.UNLOAD,
-        Action.INFO,
-        Action.CANCEL,
-      ],
-      [Status.UNLOADED]: [Action.LOAD_AND_SWITCH, Action.LOAD, Action.CANCEL],
-      [Status.UNAUTHORIZED]: [Action.INFO, Action.CANCEL],
+          ? [Action.SWITCH, Action.UNLOAD, ...base]
+          : [Action.SWITCH, ...base],
+      [Status.LOADING]: [...base],
+      [Status.FAILED]: [Action.RETRY, ...base],
+      [Status.SLEEPING]: [Action.SWITCH, Action.UNLOAD, ...base],
+      [Status.UNLOADED]: [Action.LOAD_AND_SWITCH, Action.LOAD, ...base],
+      [Status.UNAUTHORIZED]: [...base],
     };
 
     const status = await model.getStatus();
-    return allActions[status];
+    return actions[status];
   }
 
   /**

package/src/managers/events.ts

@@ -5,17 +5,35 @@ import {
 import { READABLE_TIMEOUT } from "../constants";
 import { Status } from "../enums/status";
 import { ModelSelectEvent } from "../interfaces/events";
-import { settings } from "../managers/settings";
+import type { LlamaSettingsManager } from "../managers/settings";
 import { BaseModel } from "../models/baseModel";
-import { Server } from "../server";
+import { ServerManager } from "./server";
 
 export class EventManager {
+  /**
+   * Model with a load currently in flight. Deliberately a class static
+   * (REFACTOR.md §3.3): the load is started by CommandManager
+   * (fire-and-forget from the /models editor) while the "session switched
+   * mid-load" warning must be emitted here, from the session_before_switch
+   * hook — a shared static is the least-plumbing bridge between the two
+   * event-owning managers.
+   *
+   * Known limits, accepted: (1) single slot — a second overlapping load
+   * overwrites the first, and the first load's onFinished reset can clear
+   * the flag while the second is still loading, so the session-switch
+   * warning may be missed; (2) loads initiated from this class
+   * (onModelSelect / autoLoadIfNeeded) never set the flag.
+   */
   static inflightModel: BaseModel | null = null;
 
-  constructor(private readonly servers: Server[]) {}
+  constructor(
+    private readonly serverManager: ServerManager,
+    private readonly settings: LlamaSettingsManager,
+  ) {}
 
   /**
-   * Resets the in-flight model reference.
+   * Resets the in-flight model reference. Called by CommandManager when
+   * its load settles (see `inflightModel` for why this lives on a static).
    */
   static resetInflightModel() {
     EventManager.inflightModel = null;
@@ -29,9 +47,9 @@ export class EventManager {
    */
   async onModelSelect(event: ModelSelectEvent, ctx: ExtensionContext) {
     // Check if the model_select event should be used
-    if (!settings.resolveReactToModelSelect()) return;
+    if (!this.settings.resolveReactToModelSelect()) return;
 
-    for (const { providerId, models } of this.servers) {
+    for (const { providerId, models } of this.serverManager.servers) {
       if (event.model.provider !== providerId) continue;
 
       const model = models.find((m) => m.id === event.model.id);
@@ -54,7 +72,7 @@ export class EventManager {
    * @param model The model to potentially auto-load
    */
   private async autoLoadIfNeeded(model: BaseModel): Promise<void> {
-    if (!settings.resolveAutoloadOnMessage()) return;
+    if (!this.settings.resolveAutoloadOnMessage()) return;
 
     const status = await model.getStatus();
     if (status !== Status.UNLOADED) return;
@@ -99,7 +117,7 @@ export class EventManager {
     if (!model) return payload;
 
     // Check if this model belongs to one of our servers
-    const serverModel = this.servers
+    const serverModel = this.serverManager.servers
       .flatMap((s) => s.models)
       .find((m) => m.id === model);
 
@@ -110,8 +128,8 @@ export class EventManager {
 
     // Retrieve pi's current thinking level, so we can setup a budget
     const level =
-      ctx.thinkingLevel ?? settings.resolveThinkingLevel() ?? "medium";
-    const budgets = settings.resolveThinkingBudgets();
+      ctx.thinkingLevel ?? this.settings.resolveThinkingLevel() ?? "medium";
+    const budgets = this.settings.resolveThinkingBudgets();
     const thinking_budget_tokens = budgets[level];
 
     // Setup payload

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 } = 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 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,58 @@ 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.
    *
    * @returns Flat array of all models across all servers
    */
   getAllModels(): BaseModel[] {
-    const response = [];
+    const sortBy = this.settings.resolveSortBy();
+    const allModels = this.servers.flatMap((s) => s.models);
 
-    for (const { models } of this.servers) {
-      for (const model of models) {
-        response.push(model);
-      }
-    }
+    if (sortBy === "api") return allModels;
 
-    return response;
+    return allModels.sort(ServerManager.SORTERS[sortBy]);
   }
+
+  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 each sort mode except "api", which preserves server
+   * order (short-circuited in {@link ServerManager.getAllModels}).
+   */
+  private static readonly SORTERS: Record<
+    Exclude<SortBy, "api">,
+    ModelComparator
+  > = {
+    asc: ServerManager.sortByIdAsc,
+    desc: ServerManager.sortByIdDesc,
+    "asc-name": ServerManager.sortByNameAsc,
+    "desc-name": ServerManager.sortByNameDesc,
+  };
 }