pi-llama-cpp 0.10.0 → 0.12.0

package/src/managers/command.ts

@@ -1,18 +1,186 @@
-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 { createOverrideSettingsList } from "../ui/overrideSettingsList";
+import { ServerSettingsList } from "../ui/serverSettingsList";
+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: "settings",
+    label: "settings",
+    description: "Configure llamaSettings",
+  },
+  {
+    value: "servers",
+    label: "servers",
+    description: "Manage llama.cpp server URLs",
+  },
+  {
+    value: "overrides",
+    label: "overrides",
+    description: "Manage llama.cpp model overrides",
+  },
+];
+
+/**
+ * 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 = async (
+  settings: LlamaSettingsManager,
+): 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: (await 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: (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: await 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 +189,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 +207,27 @@ 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: re-registers providers after editing so changes
+    // (add / remove / URL / id / name) apply immediately
+    if (args === "servers") {
+      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;
+    }
+
     // Re-register providers so Pi sees updated model states
     await this.serverManager.update(pi);
 
@@ -58,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;
     }
@@ -77,6 +254,142 @@ 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. These settings
+   * (reactToModelSelect, autoloadOnMessage, sortBy, timeouts) do not
+   * require provider re-registration.
+   */
+  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 = await 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 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. After closing,
+   * providers are re-registered so server changes apply immediately.
+   */
+  private async runServersEditor(
+    ctx: ExtensionCommandContext,
+    pi: ExtensionAPI,
+  ): Promise<void> {
+    if (ctx.mode !== "tui") {
+      ctx.ui.notify(
+        "/models servers requires an interactive session (TUI)",
+        "warning",
+      );
+      return;
+    }
+
+    const servers = await this.settings.getLlamaServers();
+
+    await ctx.ui.custom<void>(
+      (tui, theme, keybindings, done) =>
+        new ServerSettingsList({
+          tui,
+          theme,
+          keybindings,
+          servers,
+          persist: (next) => this.settings.setLlamaSetting("servers", next),
+          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.
    */
@@ -93,7 +406,7 @@ export class CommandManager {
   ): Promise<void> {
     const event = await this.modelSelectionHandler(
       ctx,
-      this.serverManager.getAllModels(),
+      await this.serverManager.getAllModels(),
     );
 
     if (!event) return;
@@ -132,18 +445,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 +487,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 +587,25 @@ 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]:
+        model.mode === Mode.ROUTER
+          ? [Action.SWITCH, Action.UNLOAD, ...base]
+          : [Action.SWITCH, ...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 (!(await 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 (!(await 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