pi-llama-cpp 0.10.0 → 0.12.0

package/src/server.ts

@@ -1,10 +1,8 @@
 import { ApiClient } from "./api/client";
 import {
   API_KEY_PLACEHOLDER,
-  POLLING_TIMEOUT,
   PROVIDER_NAME,
   PROVIDER_PREFIX,
-  SERVER_TIMEOUT,
 } from "./constants";
 import { Mode } from "./enums/mode";
 import { ServerStatus } from "./enums/serverStatus";
@@ -14,25 +12,68 @@ import {
   PropsEndpoint,
   PropsModelEndpoint,
 } from "./interfaces/endpoints/props";
-import { settings } from "./managers/settings";
+import type { ServerOptions } from "./interfaces/server";
+import type { ModelOverride } from "./interfaces/settings";
+import type { LlamaSettingsManager } from "./managers/settings";
 import { BaseModel } from "./models/baseModel";
 import { LegacyModel } from "./models/legacyModel";
 import { RouterModel } from "./models/routerModel";
 import { SingleModel } from "./models/singleModel";
 import { SSEManager } from "./sse/manager";
 
+/**
+ * Optional constructor collaborators for {@link Server} — the seam tests use
+ * to run the real Server against fake clients.
+ *
+ * Both are factories because their arguments only exist around construction:
+ * the API key is (re-)resolved by the Server, and SSEManager needs its owner.
+ * Factories must stay pure functions of their arguments — `initialize()`
+ * re-invokes both on every scan (the ApiClient rebuild picks up a fresh key,
+ * by design), so captured per-server state would leak across re-scans.
+ */
+export type ServerDeps = {
+  createApiClient?: (apiKey: string) => ApiClient;
+  createSSEManager?: (server: Server, apiKey: string) => SSEManager;
+};
+
 export class Server {
   public readonly models: BaseModel[] = [];
-  private apiClient!: ApiClient;
+  private apiClient: ApiClient;
   private sse!: SSEManager;
 
   constructor(
-    readonly baseUrl: string,
-    private readonly customId?: string,
-    private readonly customName?: string,
-    readonly serverTimeout: number = SERVER_TIMEOUT,
-    readonly pollingTimeout: number = POLLING_TIMEOUT,
-  ) {}
+    private readonly settings: LlamaSettingsManager,
+    private readonly options: ServerOptions,
+    private readonly deps: ServerDeps = {},
+  ) {
+    // Eager client: `isReady` may run before `initialize()` (health probing
+    // in ServerManager), so no lazy fallback is needed. initialize()
+    // rebuilds the client to re-resolve the API key.
+    this.apiClient =
+      deps.createApiClient?.(this.getApiKey()) ??
+      new ApiClient(options.baseUrl, this.getApiKey());
+  }
+
+  /** Base URL of this server endpoint. */
+  get baseUrl(): string {
+    return this.options.baseUrl;
+  }
+
+  /**
+   * Maximum time (ms) for server verification and SSE support probe.
+   * Resolved live from the injected settings manager.
+   */
+  async getServerTimeout(): Promise<number> {
+    return (await this.settings.resolveTimeouts()).serverTimeout;
+  }
+
+  /**
+   * Maximum time (ms) to wait for model loading before giving up.
+   * Resolved live from the injected settings manager.
+   */
+  async getPollingTimeout(): Promise<number> {
+    return (await this.settings.resolveTimeouts()).pollingTimeout;
+  }
 
   /**
    * Provides access to the SSE manager for direct subscriptions.
@@ -46,7 +87,7 @@ export class Server {
    * Uses custom ID if provided, otherwise falls back to URL-based ID.
    */
   get providerId(): string {
-    return this.customId ?? `${PROVIDER_PREFIX}=${this.baseUrl}`;
+    return this.options.customId ?? `${PROVIDER_PREFIX}=${this.baseUrl}`;
   }
 
   /**
@@ -54,8 +95,8 @@ export class Server {
    * Uses custom name as suffix if provided.
    */
   get providerName(): string {
-    if (this.customName) {
-      return `${PROVIDER_NAME} (${this.customName})`;
+    if (this.options.customName) {
+      return `${PROVIDER_NAME} (${this.options.customName})`;
     }
     return `${PROVIDER_NAME} (${this.baseUrl})`;
   }
@@ -68,12 +109,12 @@ export class Server {
    */
   getApiKey(): string {
     // Try custom ID first
-    if (this.customId) {
-      const key = settings.resolveApiKey(this.customId);
+    if (this.options.customId) {
+      const key = this.settings.resolveApiKey(this.options.customId);
       if (key !== API_KEY_PLACEHOLDER) return key;
     }
     // Fall back to URL-based ID
-    return settings.resolveApiKey(`${PROVIDER_PREFIX}=${this.baseUrl}`);
+    return this.settings.resolveApiKey(`${PROVIDER_PREFIX}=${this.baseUrl}`);
   }
 
   /**
@@ -81,11 +122,15 @@ export class Server {
    * Clears the cache first so we always fetch fresh data.
    */
   async initialize() {
-    const apiKey = await this.getApiKey();
-    this.apiClient = new ApiClient(this.baseUrl, apiKey);
-    this.sse = new SSEManager(this.baseUrl, apiKey, this.serverTimeout);
+    const apiKey = this.getApiKey();
+    this.apiClient =
+      this.deps.createApiClient?.(apiKey) ??
+      new ApiClient(this.baseUrl, apiKey);
+    this.sse =
+      this.deps.createSSEManager?.(this, apiKey) ??
+      new SSEManager(this, apiKey);
     const { data } = await this.fetchModels();
-    const mode = await this.detectServerMode();
+    const mode = await this.detectServerMode(data);
 
     // Setup models
     const modelCtor = {
@@ -94,22 +139,21 @@ export class Server {
       [Mode.SINGLE]: SingleModel,
     }[mode];
 
-    const models: BaseModel[] = data
-      .map((m) => new modelCtor(m, this))
-      .sort((a, b) => (a.id > b.id ? 1 : a.id === b.id ? 0 : -1));
+    const models: BaseModel[] = data.map((m) => new modelCtor(m, this));
 
     this.models.length = 0;
     this.models.push(...models);
   }
 
   /**
-   * Detects the mode of the server
+   * Detects the mode of the server from the models data already fetched by
+   * {@link initialize} — no second /v1/models round-trip.
    *
+   * @param data Models endpoint data fetched by initialize()
    * @returns The detected mode
    */
-  private async detectServerMode(): Promise<Mode> {
+  private async detectServerMode(data: ModelsEndpoint["data"]): Promise<Mode> {
     const { role } = await this.fetchServerProps();
-    const { data } = await this.fetchModels();
 
     if (role === "router") return Mode.ROUTER;
     if ("max_model_len" in data[0]) return Mode.LEGACY;
@@ -123,8 +167,6 @@ export class Server {
    * @returns The server status
    */
   async isReady(timeout: number): Promise<ServerStatus> {
-    this.apiClient ??= new ApiClient(this.baseUrl, await this.getApiKey());
-
     try {
       const timeoutPromise = new Promise<never>((_, reject) =>
         setTimeout(() => reject(new Error("timeout")), timeout),
@@ -184,6 +226,39 @@ export class Server {
     );
   }
 
+  /**
+   * Returns the per-model override configuration for this server.
+   */
+  getOverrides(): Record<string, ModelOverride> {
+    return this.options.overrides ?? {};
+  }
+
+  /**
+   * Resolves the override for a given model ID using prefix matching.
+   *
+   * Keys in the overrides map are treated as prefix filters — a model ID
+   * matches if it starts with the key. When multiple keys match, the
+   * longest (most specific) key wins. Empty keys are ignored.
+   *
+   * @param modelId — The model ID to look up.
+   * @returns The matching override, or `undefined` if no key matches.
+   */
+  findOverrideForModel(modelId: string): ModelOverride | undefined {
+    const overrides = this.getOverrides();
+    let best: ModelOverride | undefined;
+    let bestLen = 0;
+
+    for (const [key, override] of Object.entries(overrides)) {
+      if (!key) continue;
+      if (modelId.startsWith(key) && key.length > bestLen) {
+        best = override;
+        bestLen = key.length;
+      }
+    }
+
+    return best;
+  }
+
   /**
    * Sends a request associated to a specific model from the server
    *

package/src/sse/client.ts

@@ -1,6 +1,18 @@
 import { POLLING_INTERVAL } from "../constants";
 import type { SSECallback, SSECleanup, SSEEvent } from "./types";
 
+/**
+ * Builds the full SSE endpoint URL, appending the API key as a query
+ * parameter when one is set. Shared by {@link SSEClient} and
+ * {@link SSEManager.probeSSE} so the two can't drift.
+ */
+export const buildSSEUrl = (endpoint: string, apiKey?: string): string => {
+  if (apiKey) {
+    return `${endpoint}?api_key=${encodeURIComponent(apiKey)}`;
+  }
+  return endpoint;
+};
+
 /**
  * SSE client for llama-server's /models/sse endpoint.
  *
@@ -13,6 +25,10 @@ export class SSEClient {
   private subscribers: Map<string, SSECallback> = new Map();
   private connected: boolean = false;
   private reconnecting: boolean = false; // tracks if EventSource auto-reconnect is in progress
+  /**
+   * Single shared slot — each setOnConnectFailed call overwrites the
+   * previous callback (see there for the constraint this imposes).
+   */
   private _onConnectFailed: (() => void) | null = null;
   private _hasReceivedEvents: boolean = false;
 
@@ -28,12 +44,16 @@ export class SSEClient {
   /**
    * Connects to the SSE endpoint.
    *
+   * No current caller consumes the result: `subscribe()` triggers the
+   * connection without awaiting it, and connection failures before the
+   * first event are surfaced through the `setOnConnectFailed` callback.
+   *
    * @returns true if the connection was established successfully
    */
   async connect(): Promise<boolean> {
     if (this.connected) return true;
 
-    const url = this.buildUrl();
+    const url = buildSSEUrl(this.sseEndpoint, this.apiKey);
 
     try {
       this.eventSource = new EventSource(url);
@@ -42,11 +62,6 @@ export class SSEClient {
       return false;
     }
 
-    this.eventSource.onopen = () => {
-      this.connected = true;
-      this.reconnecting = false;
-    };
-
     this.eventSource.onerror = () => {
       // EventSource will auto-reconnect; we just track state
       this.connected = false;
@@ -91,6 +106,13 @@ export class SSEClient {
    * Sets a callback to be called when the connection fails before
    * any event is received. Useful for rejecting promises early.
    *
+   * Single shared slot: each call overwrites the previous callback, so at
+   * most one caller may depend on it at a time. The only caller today is
+   * `SSEManager.subscribeToStatus`, which must therefore not be invoked
+   * twice concurrently on the same client — the second registration would
+   * take over the failure signal and the first promise would only reject
+   * via its own timeout.
+   *
    * @param callback - Called once when connection fails
    */
   setOnConnectFailed(callback: () => void): void {
@@ -129,16 +151,6 @@ export class SSEClient {
     this.subscribers.clear();
   }
 
-  /**
-   * Builds the full URL with optional API key query param.
-   */
-  private buildUrl(): string {
-    if (this.apiKey) {
-      return `${this.sseEndpoint}?api_key=${encodeURIComponent(this.apiKey)}`;
-    }
-    return this.sseEndpoint;
-  }
-
   /**
    * Dispatches an SSE event to all matching subscribers.
    */

package/src/sse/manager.ts

@@ -1,5 +1,5 @@
-import { POLLING_TIMEOUT, SERVER_TIMEOUT } from "../constants";
-import { SSEClient } from "./client";
+import type { Server } from "../server";
+import { SSEClient, buildSSEUrl } from "./client";
 import {
   DownloadProgressData,
   ProgressData,
@@ -25,16 +25,31 @@ export class SSEManager {
   private sseSupported: boolean | null = null;
 
   constructor(
-    private readonly baseUrl: string,
+    private readonly server: Server,
     private readonly apiKey: string,
-    readonly serverTimeout: number = SERVER_TIMEOUT,
   ) {}
 
+  /**
+   * Maximum time (ms) for server verification and SSE support probe.
+   * Delegates to the owning {@link Server}.
+   */
+  async getServerTimeout(): Promise<number> {
+    return this.server.getServerTimeout();
+  }
+
+  /**
+   * Maximum time (ms) to wait for model loading before giving up.
+   * Delegates to the owning {@link Server}.
+   */
+  async getPollingTimeout(): Promise<number> {
+    return this.server.getPollingTimeout();
+  }
+
   /**
    * The SSE endpoint URL.
    */
   private get sseEndpoint(): string {
-    return `${this.baseUrl}/models/sse`;
+    return `${this.server.baseUrl}/models/sse`;
   }
 
   /**
@@ -47,13 +62,10 @@ export class SSEManager {
     if (this.sseSupported !== null) return this.sseSupported;
 
     try {
-      let url = this.sseEndpoint;
-      if (this.apiKey) {
-        url = `${url}?api_key=${encodeURIComponent(this.apiKey)}`;
-      }
+      const url = buildSSEUrl(this.sseEndpoint, this.apiKey);
       const response = await fetch(url, {
         method: "GET",
-        signal: AbortSignal.timeout(this.serverTimeout),
+        signal: AbortSignal.timeout(await this.getServerTimeout()),
       });
       this.sseSupported =
         response.ok &&
@@ -167,11 +179,12 @@ export class SSEManager {
    * @param modelId - The model ID to subscribe to
    * @returns Promise that resolves with the final status string
    */
-  subscribeToStatus(modelId: string): Promise<StatusChangeData> {
-    return new Promise((resolve, reject) => {
+  async subscribeToStatus(modelId: string): Promise<StatusChangeData> {
+    return new Promise(async (resolve, reject) => {
+      const pollingTimeout = await this.getPollingTimeout();
       const timeout = setTimeout(
         () => reject(new Error(`SSE status timeout for model: ${modelId}`)),
-        POLLING_TIMEOUT,
+        pollingTimeout,
       );
 
       this.subscribeToSSE(modelId, (event: SSEEvent) => {

package/src/ui/dialog.ts

@@ -0,0 +1,287 @@
+import { DynamicBorder, type Theme } from "@earendil-works/pi-coding-agent";
+import type {
+  Component,
+  Keybinding,
+  SelectListTheme,
+  TUI,
+} from "@earendil-works/pi-tui";
+import {
+  Container,
+  getKeybindings,
+  Input,
+  SelectList,
+  Spacer,
+  Text,
+} from "@earendil-works/pi-tui";
+
+/**
+ * Base dialog class encapsulating shared UI utilities (frame, hints,
+ * themes) so concrete dialogs don't duplicate code.
+ */
+abstract class BaseDialog {
+  protected theme: Theme;
+  protected tui: TUI;
+
+  constructor(theme: Theme, tui: TUI) {
+    this.theme = theme;
+    this.tui = tui;
+  }
+
+  // -- shared utilities ------------------------------------------------------
+
+  protected selectListTheme(): SelectListTheme {
+    return {
+      selectedPrefix: (text) => this.theme.fg("accent", text),
+      selectedText: (text) => this.theme.fg("accent", text),
+      description: (text) => this.theme.fg("muted", text),
+      scrollInfo: (text) => this.theme.fg("dim", text),
+      noMatch: (text) => this.theme.fg("warning", text),
+    };
+  }
+
+  protected hint(action: Keybinding, description: string): string {
+    const keys = getKeybindings().getKeys(action).join("/");
+    return (
+      this.theme.fg("dim", keys) + this.theme.fg("muted", ` ${description}`)
+    );
+  }
+
+  protected inputFooter(): string {
+    return `${this.hint("tui.select.confirm", "save")} • ${this.hint("tui.select.cancel", "cancel")}`;
+  }
+
+  protected selectFooter(): string {
+    return `${this.hint("tui.select.confirm", "select")} • ${this.hint("tui.select.cancel", "cancel")}`;
+  }
+
+  protected createFrame(
+    title: string,
+    body: Component[],
+    footer?: string,
+  ): Container {
+    const container = new Container();
+    container.addChild(
+      new DynamicBorder((text) => this.theme.fg("accent", text)),
+    );
+    container.addChild(
+      new Text(this.theme.fg("accent", this.theme.bold(title)), 1, 0),
+    );
+    for (const child of body) container.addChild(child);
+    if (footer) {
+      container.addChild(new Spacer(1));
+      container.addChild(new Text(this.theme.fg("dim", footer), 1, 0));
+    }
+    container.addChild(
+      new DynamicBorder((text) => this.theme.fg("accent", text)),
+    );
+    return container;
+  }
+}
+
+/**
+ * Shared `SettingItem.submenu` factory for the text fields of both editors.
+ * Opens an `InputDialog` pre-filled with `initialValue`; Enter commits the
+ * validated value via `done(value)`, Esc cancels via `done(undefined)`.
+ */
+export class InputDialog extends BaseDialog {
+  private readonly options: InputDialogOptions;
+  private readonly body = new Container();
+  private readonly container: Container;
+  private readonly input = new Input();
+  private errorText: Text | undefined;
+
+  constructor(options: InputDialogOptions) {
+    super(options.theme, options.tui);
+    this.options = options;
+
+    const initial = options.initialValue ?? "";
+    this.input.setValue(initial);
+    for (let i = 0; i < [...initial].length; i++) {
+      this.input.handleInput("\x1b[C");
+    }
+    this.input.onSubmit = (value) => this.submit(value);
+    this.input.onEscape = () => options.onCancel();
+
+    this.body.addChild(new Text(this.theme.fg("text", options.message), 1, 0));
+    if (options.placeholder) {
+      this.body.addChild(
+        new Text(this.theme.fg("dim", `e.g., ${options.placeholder}`), 1, 0),
+      );
+    }
+    this.body.addChild(this.input);
+
+    this.container = this.createFrame(
+      options.title,
+      [this.body],
+      this.inputFooter(),
+    );
+  }
+
+  // -- Component -------------------------------------------------------------
+
+  invalidate(): void {
+    this.container.invalidate();
+  }
+
+  handleInput(data: string): void {
+    this.input.handleInput(data);
+    this.tui.requestRender();
+  }
+
+  render(width: number): string[] {
+    return this.container.render(width);
+  }
+
+  // -- Focusable ---------------------------------------------------------------
+
+  get focused(): boolean {
+    return this.input.focused;
+  }
+
+  set focused(value: boolean) {
+    this.input.focused = value;
+  }
+
+  // -- helpers -------------------------------------------------------------------
+
+  private submit(raw: string): void {
+    const validated = this.options.validate ? this.options.validate(raw) : raw;
+    if (validated === null) {
+      this.setError(`Invalid value "${raw}"`);
+      return;
+    }
+    this.options.onSubmit(validated);
+  }
+
+  private setError(message: string | undefined): void {
+    if (this.errorText) {
+      this.body.removeChild(this.errorText);
+      this.errorText = undefined;
+    }
+    if (message) {
+      this.errorText = new Text(this.theme.fg("error", message), 1, 0);
+      this.body.addChild(this.errorText);
+    }
+    this.tui.requestRender();
+  }
+
+  /**
+   * Builds a `SettingItem.submenu` factory that opens an `InputDialog`.
+   */
+  static inputSubmenu =
+    (
+      theme: Theme,
+      tui: TUI,
+      title: string,
+      message: string,
+      placeholder: string | undefined,
+      initialValue: string,
+      validate?: (raw: string) => string | null,
+    ) =>
+    (
+      _currentValue: string,
+      done: (selectedValue?: string) => void,
+    ): Component => {
+      const dialog = new InputDialog({
+        theme,
+        tui,
+        title,
+        message,
+        placeholder,
+        initialValue,
+        validate,
+        onSubmit: (value) => done(value),
+        onCancel: () => done(undefined),
+      });
+      dialog.focused = true;
+      return dialog;
+    };
+}
+
+export interface InputDialogOptions {
+  theme: Theme;
+  tui: TUI;
+  title: string;
+  message: string;
+  placeholder?: string;
+  initialValue?: string;
+  validate?: (raw: string) => string | null;
+  onSubmit: (value: string) => void;
+  onCancel: () => void;
+}
+
+/**
+ * A framed confirmation dialog with a two-option `SelectList`
+ * (Delete / Cancel), matching the confirm pattern of pi's `/llama` view.
+ */
+export class ConfirmDialog extends BaseDialog {
+  private readonly options: ConfirmDialogOptions;
+  private readonly container: Container;
+  private readonly list: SelectList;
+  private isFocused = false;
+
+  constructor(options: ConfirmDialogOptions) {
+    super(options.theme, options.tui);
+    this.options = options;
+
+    this.list = new SelectList(
+      [
+        { value: "confirm", label: options.confirmLabel ?? "Delete" },
+        { value: "cancel", label: options.cancelLabel ?? "Cancel" },
+      ],
+      2,
+      this.selectListTheme(),
+    );
+    this.list.onSelect = (item) => {
+      if (item.value === "confirm") options.onConfirm();
+      else options.onCancel();
+    };
+    this.list.onCancel = () => options.onCancel();
+
+    this.container = this.createFrame(
+      options.title,
+      [
+        new Text(this.theme.fg("text", options.message), 1, 0),
+        new Spacer(1),
+        this.list,
+      ],
+      this.selectFooter(),
+    );
+  }
+
+  // -- Component -------------------------------------------------------------
+
+  invalidate(): void {
+    this.container.invalidate();
+  }
+
+  handleInput(data: string): void {
+    this.list.handleInput(data);
+    this.tui.requestRender();
+  }
+
+  render(width: number): string[] {
+    return this.container.render(width);
+  }
+
+  // -- Focusable ---------------------------------------------------------------
+
+  get focused(): boolean {
+    return this.isFocused;
+  }
+
+  set focused(value: boolean) {
+    this.isFocused = value;
+  }
+}
+
+export interface ConfirmDialogOptions {
+  theme: Theme;
+  tui: TUI;
+  title: string;
+  message: string;
+  confirmLabel?: string;
+  cancelLabel?: string;
+  onConfirm: () => void;
+  onCancel: () => void;
+}