pi-llama-cpp 0.12.0 → 0.14.0

package/src/managers/command.ts

@@ -1,54 +1,16 @@
-import {
-  getSettingsListTheme,
-  type ExtensionAPI,
-  type ExtensionCommandContext,
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
 } from "@earendil-works/pi-coding-agent";
-import {
-  AutocompleteItem,
-  SettingsList,
-  type SettingItem,
-} from "@earendil-works/pi-tui";
+import { AutocompleteItem } 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 { OverrideSettingsList } from "../ui/editors/override/overrideList";
+import { ServerSettingsList } from "../ui/editors/server/serverEditor";
+import { SettingsEditor } from "../ui/settings";
+import { ModelsMenu } from "./command/models";
 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
@@ -82,105 +44,15 @@ const ARGUMENT_COMPLETIONS: AutocompleteItem[] = [
   },
 ];
 
-/**
- * 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 {
+  private readonly modelsMenu: ModelsMenu;
+
   constructor(
     private readonly serverManager: ServerManager,
     private readonly settings: LlamaSettingsManager,
-  ) {}
+  ) {
+    this.modelsMenu = new ModelsMenu(serverManager);
+  }
 
   /**
    * Sets up the argument completions for the `/models` command
@@ -207,8 +79,8 @@ export class CommandManager {
     ctx: ExtensionCommandContext,
     pi: ExtensionAPI,
   ) {
-    // Settings menu: no network round-trip needed, handle before any
-    // server updates / unreachable-server notifications
+    // Settings menu: no provider re-registration needed (sortBy, timeouts,
+    // etc. don't affect the model registry)
     if (args === "settings") {
       await this.runSettingsMenu(ctx);
       return;
@@ -251,18 +123,12 @@ export class CommandManager {
     }
 
     // Interactive menu: show <name> (<server_url>)
-    await this.runModelsMenu(ctx, pi);
+    await this.modelsMenu.show(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") {
@@ -273,36 +139,12 @@ export class CommandManager {
       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),
-        ),
-    );
+    await SettingsEditor.show(ctx.ui, this.settings);
   }
 
   /**
-   * 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,
+   * Runs the interactive servers editor for `llamaSettings.servers`
+   * (see `ServerSettingsList` for the editing semantics). After closing,
    * providers are re-registered so server changes apply immediately.
    */
   private async runServersEditor(
@@ -317,47 +159,17 @@ export class CommandManager {
       return;
     }
 
-    const servers = await this.settings.getLlamaServers();
+    await ServerSettingsList.show(ctx.ui, this.settings);
 
-    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"),
-        }),
-    );
+    // Re-register providers so the updated server list takes effect
+    await this.serverManager.update(pi);
   }
 
   /**
    * 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.
+   * `llamaSettings.servers[].overrides` (see `OverrideSettingsList` for
+   * the editing semantics). After closing, providers are re-registered
+   * so new overrides take effect on the next request.
    */
   private async runOverridesEditor(
     ctx: ExtensionCommandContext,
@@ -371,23 +183,10 @@ export class CommandManager {
       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
-      }),
-    );
+    await OverrideSettingsList.show(ctx.ui, this.settings);
+
+    // Re-register providers so the updated overrides take effect
+    await this.serverManager.update(pi);
   }
 
   /**
@@ -396,233 +195,4 @@ export class CommandManager {
   private notifyNotFound(ctx: ExtensionCommandContext, url: string): void {
     ctx.ui.notify(`${PROVIDER_NAME} unreachable at ${url}`, "error");
   }
-
-  /**
-   * Runs the interactive model selection menu.
-   */
-  private async runModelsMenu(
-    ctx: ExtensionCommandContext,
-    pi: ExtensionAPI,
-  ): Promise<void> {
-    const event = await this.modelSelectionHandler(
-      ctx,
-      await this.serverManager.getAllModels(),
-    );
-
-    if (!event) return;
-    const { action, model } = event;
-
-    // Action: Cancel
-    if (!action || action === Action.CANCEL) return;
-
-    // Action: Info
-    if (action === Action.INFO) {
-      const info = await model.getInfo();
-      ctx.ui.notify(`${info}`, "info");
-      return;
-    }
-
-    // Action: Unload
-    if (action === Action.UNLOAD) {
-      await model.unload();
-      ctx.ui.notify(`Unloaded ${model.name}`, "info");
-      return;
-    }
-
-    // Action: Switch
-    if (action === Action.SWITCH) {
-      const { serverId } = model;
-      const piModel = ctx.modelRegistry.find(serverId, model.id);
-      if (!piModel)
-        throw new Error(`Cannot find model ${model.name} in pi registry`);
-
-      await pi.setModel(piModel);
-      ctx.ui.notify(`Model ${model.name} ready`, "info");
-      return;
-    }
-
-    // Actions: Load / Load & Switch / Retry
-    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; 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;
-        const piModel = ctx.modelRegistry.find(serverId, model.id);
-        if (!piModel)
-          throw new Error(`Cannot find model ${model.name} in pi registry`);
-
-        // Verify auth
-        if ((await model.getStatus()) === Status.UNAUTHORIZED)
-          throw new Error(
-            `Unauthorized for ${model.name}. Use /login and add your API key.`,
-          );
-
-        // Verify failure
-        if ((await model.getStatus()) === Status.FAILED)
-          throw new Error(`Failed to load model ${model.name}`);
-
-        // Select the model if asked
-        if (action === Action.LOAD_AND_SWITCH) await pi.setModel(piModel);
-
-        ctx.ui.notify(`Model ${model.name} ready`, "info");
-      };
-
-      const onFailure = (err: any) => {
-        const message = errorMessage(err);
-
-        try {
-          ctx.ui.notify(message, "error");
-        } catch {
-          // ctx went stale between error and notification
-        }
-      };
-
-      const onFinished = async () => {
-        cleanupProgress();
-        EventManager.resetInflightModel();
-
-        // Re-scan providers to ensure accuracy of loaded models
-        await this.serverManager.update(pi);
-
-        // Force TUI refresh so Pi picks up the updated model states
-        ctx.ui.setStatus(PROVIDER_NAME, " ");
-        ctx.ui.setStatus(PROVIDER_NAME, undefined);
-      };
-
-      // Load the model without blocking the UI
-      model.load().then(onSuccess).catch(onFailure).finally(onFinished);
-    }
-  }
-
-  /**
-   * Handles the menu for model selection.
-   * Loops: select model → select action → handle action.
-   *
-   * Escape on actions menu goes back to model selection.
-   * Escape on model selection exits.
-   *
-   * @returns The selected action and model
-   */
-  private async modelSelectionHandler(
-    ctx: ExtensionCommandContext,
-    models: BaseModel[],
-  ): Promise<{ action: Action; model: BaseModel } | null> {
-    while (true) {
-      // Select the model
-      const model = await this.selectModel(ctx, models);
-      if (!model) return null;
-
-      // Select the action
-      const actions = await this.getActionsForModel(model);
-      const action = await this.selectAction(ctx, model, actions);
-      if (action === null) {
-        // Escape key pressed => back to model selection
-        continue;
-      }
-
-      // Return the selected action and model
-      return { action, model };
-    }
-  }
-
-  /**
-   * Select a model from the list. Returns null if user cancels.
-   *
-   * @returns The model selected by the user
-   */
-  private async selectModel(
-    ctx: ExtensionCommandContext,
-    models: BaseModel[],
-  ): Promise<BaseModel | null> {
-    const labels = await Promise.all(
-      models.map(async (model) => ({
-        label: (await model.getLabel()).trim(),
-        serverUrl: model.serverUrl,
-      })),
-    );
-
-    // Count grapheme clusters (not UTF-16 code units) so emoji padding aligns visually
-    const graphemeLength = (str: string) =>
-      [...new Intl.Segmenter().segment(str)].length;
-
-    // Decorate the label so the spacing makes it seem more like a table
-    const maxLength = Math.max(
-      ...labels.map(({ label }) => graphemeLength(label)),
-    );
-    const choices = labels.map(({ label, serverUrl }) => {
-      const extraPadding = 2;
-      const padLen = maxLength - graphemeLength(label) + extraPadding;
-      return `${label}${" ".repeat(padLen)} [Server: ${serverUrl}]`;
-    });
-
-    const choice = await ctx.ui.select(`${PROVIDER_NAME} models:`, choices);
-    if (!choice) return null;
-    const idx = choices.indexOf(choice);
-
-    return models[idx];
-  }
-
-  /**
-   * Get available actions for a model based on its mode and status.
-   *
-   * @returns A mapping of actions for each status
-   */
-  private async getActionsForModel(model: BaseModel): Promise<Array<Action>> {
-    const base = [Action.INFO, Action.CANCEL];
-
-    const actions: Record<Status, Array<Action>> = {
-      [Status.LOADED]:
-        model.mode === Mode.ROUTER
-          ? [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 actions[status];
-  }
-
-  /**
-   * Selects an action for a model.
-   *
-   * @returns The selected action
-   */
-  private async selectAction(
-    ctx: ExtensionCommandContext,
-    model: BaseModel,
-    actions: Array<Action>,
-  ): Promise<Action | null> {
-    const labels = actions.map((a) => String(a));
-    const choice = await ctx.ui.select(`${model.name}`, labels);
-    if (!choice) return null;
-
-    const idx = labels.indexOf(choice);
-    return actions[idx];
-  }
 }

package/src/managers/events.ts

@@ -11,8 +11,8 @@ 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
+   * Model with a load currently in flight. Deliberately a class static:
+   * 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

package/src/managers/server.ts

@@ -1,6 +1,8 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { API_TYPE, PROVIDER_NAME, type SortBy } from "../constants";
+import { ApiError } from "../api/client";
+import { API_TYPE, PROVIDER_NAME } from "../constants";
 import { ServerStatus } from "../enums/serverStatus";
+import type { SortBy } from "../interfaces/sortBy";
 import { BaseModel } from "../models/baseModel";
 import { Server } from "../server";
 import type { LlamaSettingsManager } from "./settings";
@@ -80,7 +82,28 @@ export class ServerManager {
       try {
         await server.initialize();
         await this.registerProvider(server, pi);
-      } catch {
+      } catch (err) {
+        if (err instanceof ApiError && err.type === "authentication") {
+          // Register the provider with an empty model list so the user can
+          // still configure the API key via `/login` or `auth.json`. On the
+          // next scan the provider will re-initialize and discover models.
+          // Don't add to `failedUrls` — the server IS reachable, auth just
+          // isn't configured yet, so the health indicator should stay green.
+          const message = [
+            "[pi-llama-cpp]",
+            `Server at '${server.baseUrl}' requires a valid API key.`,
+            "Configure the key via `/login` or in `~/.pi/agent/auth.json`.",
+          ].join("\n");
+          this.warnings.push(message);
+          pi.registerProvider(server.providerId, {
+            name: server.providerName,
+            baseUrl: server.apiBaseUrl,
+            api: API_TYPE,
+            apiKey: server.getApiKey(),
+            models: [],
+          });
+          continue;
+        }
         this.failedUrls.push(server.baseUrl);
         continue;
       }
@@ -128,12 +151,13 @@ export class ServerManager {
   }
 
   /**
-   * Creates a Pi provider for the given server
+   * Creates a Pi provider for the given server.
    *
    * @param server The server
+   * @param pi The Pi API
    */
   private async registerProvider(server: Server, pi: ExtensionAPI) {
-    const { baseUrl, models, providerId, providerName } = server;
+    const { apiBaseUrl, models, providerId, providerName } = server;
     const apiKey = server.getApiKey();
     const modelConfigs = await Promise.all(
       models.map((m) => m.toProviderConfig()),
@@ -141,7 +165,7 @@ export class ServerManager {
 
     pi.registerProvider(providerId, {
       name: providerName,
-      baseUrl: baseUrl,
+      baseUrl: apiBaseUrl,
       api: API_TYPE,
       apiKey: apiKey,
       models: modelConfigs,