pi-llama-cpp 0.11.0 → 0.13.0

package/src/models/baseModel.ts

@@ -1,3 +1,4 @@
+import type { ModelCost } from "@earendil-works/pi-ai";
 import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
 import { FALLBACK_CTX, POLLING_INTERVAL } from "../constants";
 import { Mode } from "../enums/mode";
@@ -57,18 +58,24 @@ export abstract class BaseModel {
 
   /**
    * Whether the model is a reasoning model.
-   * Currently always returns true since there's no way to detect this from llama-server.
+   * An override's `reasoning` wins; otherwise defaults to `true`, since
+   * there's no way to detect this from llama-server.
    */
   get reasoning(): boolean {
-    return true;
+    return this.server.findOverrideForModel(this.id)?.reasoning ?? true;
   }
 
   /**
-   * Detects the capabilities of the model
+   * Detects the capabilities of the model.
+   * An override's `capabilities` fully replaces detection; otherwise the
+   * model's modalities are probed from the server.
    *
    * @returns An array of capabilities, as expected by Pi
    */
   async getCapabilities(): Promise<("text" | "image")[]> {
+    const overridden = this.server.findOverrideForModel(this.id)?.capabilities;
+    if (overridden) return overridden;
+
     try {
       // When loaded, this works alright
       const { modalities } = await this.server.fetchModelProps(this.id);
@@ -115,9 +122,16 @@ export abstract class BaseModel {
   /**
    * Gets the context size of a particular model.
    *
+   * An override's `contextSize` (when set and `> 0`) replaces detection;
+   * otherwise the value is autodetected from the server, falling back to
+   * {@link FALLBACK_CTX}. A stored `0` behaves as if the key were absent.
+   *
    * @returns The context size in tokens
    */
   async getContextSize(): Promise<number> {
+    const overridden = this.server.findOverrideForModel(this.id)?.contextSize;
+    if (overridden && overridden > 0) return overridden;
+
     try {
       const { data } = await this.server.fetchModels();
       const { n_ctx } = data.find((m) => m.id === this.id)?.meta!;
@@ -162,7 +176,18 @@ export abstract class BaseModel {
    * @returns A Pi configuration object
    */
   async toProviderConfig(): Promise<ProviderModelConfig> {
-    const response = {
+    const override = this.server.findOverrideForModel(this.id) ?? {};
+
+    // Merge the matched override's cost with zero defaults
+    const userCost = override.cost ?? {};
+    const cost: ModelCost = {
+      input: userCost.input ?? 0,
+      output: userCost.output ?? 0,
+      cacheRead: userCost.cacheRead ?? 0,
+      cacheWrite: userCost.cacheWrite ?? 0,
+    };
+
+    const response: ProviderModelConfig = {
       id: this.id,
       name: this.name,
       reasoning: this.reasoning,
@@ -176,10 +201,15 @@ export abstract class BaseModel {
       },
       input: await this.getCapabilities(),
       contextWindow: await this.getContextSize(),
-      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-      maxTokens: await this.getContextSize(),
+      cost,
+      maxTokens: override.maxTokens ?? (await this.getContextSize()),
     };
 
+    // Add compat if the override specifies it
+    if (override.compat) {
+      response.compat = override.compat;
+    }
+
     return response;
   }
 
@@ -245,7 +275,7 @@ export abstract class BaseModel {
     interval: number = POLLING_INTERVAL,
   ): Promise<void> {
     if (timeout === undefined) {
-      timeout = this.server.pollingTimeout;
+      timeout = await this.server.getPollingTimeout();
     }
     while ((await this.getStatus()) === Status.LOADING) {
       // Force a timeout if we wasted too much time polling

package/src/models/routerModel.ts

@@ -41,7 +41,8 @@ export class RouterModel extends BaseModel {
       }
     }
 
-    const timeout = this.server.pollingTimeout - elapsed;
+    const pollingTimeout = await this.server.getPollingTimeout();
+    const timeout = pollingTimeout - elapsed;
     return await super.pollStatus(startTime, timeout);
   }
 

package/src/server.ts

@@ -1,6 +1,7 @@
 import { ApiClient } from "./api/client";
 import {
   API_KEY_PLACEHOLDER,
+  ENDPOINT_PREFIX,
   PROVIDER_NAME,
   PROVIDER_PREFIX,
 } from "./constants";
@@ -13,12 +14,14 @@ import {
   PropsModelEndpoint,
 } from "./interfaces/endpoints/props";
 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";
+import { checkServerHealth } from "./utils/health";
 
 /**
  * Optional constructor collaborators for {@link Server} — the seam tests use
@@ -58,20 +61,33 @@ export class Server {
     return this.options.baseUrl;
   }
 
+  /**
+   * Base URL of the OpenAI-compatible API: {@link baseUrl} joined with
+   * {@link ENDPOINT_PREFIX}. Idempotent — a baseUrl that already ends with
+   * the prefix is returned untouched, so proxied setups exposing the API
+   * under a /v1 path don't double up.
+   */
+  get apiBaseUrl(): string {
+    const { baseUrl } = this.options;
+    return baseUrl.endsWith(ENDPOINT_PREFIX)
+      ? baseUrl
+      : `${baseUrl}${ENDPOINT_PREFIX}`;
+  }
+
   /**
    * Maximum time (ms) for server verification and SSE support probe.
    * Resolved live from the injected settings manager.
    */
-  get serverTimeout(): number {
-    return this.settings.resolveTimeouts().serverTimeout;
+  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.
    */
-  get pollingTimeout(): number {
-    return this.settings.resolveTimeouts().pollingTimeout;
+  async getPollingTimeout(): Promise<number> {
+    return (await this.settings.resolveTimeouts()).pollingTimeout;
   }
 
   /**
@@ -162,28 +178,16 @@ export class Server {
   /**
    * Checks if the server is ready, with a timeout.
    *
+   * Delegates to the shared health probe (`utils/health`) — bypasses the
+   * `ApiClient` on purpose: each caller probes once per scan, so the
+   * client's cache/dedup would be dead weight, and a plain `fetch` with
+   * `AbortSignal.timeout` actually cancels the request on timeout.
+   *
    * @param timeout Maximum time to wait for the health check
    * @returns The server status
    */
   async isReady(timeout: number): Promise<ServerStatus> {
-    try {
-      const timeoutPromise = new Promise<never>((_, reject) =>
-        setTimeout(() => reject(new Error("timeout")), timeout),
-      );
-      const health = await Promise.race([
-        this.fetchServerHealth(),
-        timeoutPromise,
-      ]);
-      if (health.status === "ok") {
-        return ServerStatus.READY;
-      }
-      return ServerStatus.UNREACHABLE;
-    } catch (error) {
-      if (error instanceof Error && error.message === "timeout") {
-        return ServerStatus.TIMEOUT;
-      }
-      return ServerStatus.UNREACHABLE;
-    }
+    return checkServerHealth(this.baseUrl, timeout, this.getApiKey());
   }
 
   /**
@@ -201,7 +205,9 @@ export class Server {
    * @return The models from the server
    */
   async fetchModels(): Promise<ModelsEndpoint> {
-    return await this.apiClient.get<ModelsEndpoint>("/v1/models");
+    return await this.apiClient.get<ModelsEndpoint>(
+      `${ENDPOINT_PREFIX}/models`,
+    );
   }
 
   /**
@@ -225,6 +231,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/manager.ts

@@ -33,16 +33,16 @@ export class SSEManager {
    * Maximum time (ms) for server verification and SSE support probe.
    * Delegates to the owning {@link Server}.
    */
-  get serverTimeout(): number {
-    return this.server.serverTimeout;
+  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}.
    */
-  get pollingTimeout(): number {
-    return this.server.pollingTimeout;
+  async getPollingTimeout(): Promise<number> {
+    return this.server.getPollingTimeout();
   }
 
   /**
@@ -65,7 +65,7 @@ export class SSEManager {
       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 &&
@@ -179,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}`)),
-        this.pollingTimeout,
+        pollingTimeout,
       );
 
       this.subscribeToSSE(modelId, (event: SSEEvent) => {

package/src/ui/dialog.ts

@@ -0,0 +1,290 @@
+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`.
+   * The dialog prefills from the `currentValue` the containing
+   * `SettingsList` passes at activation time — not a value captured at
+   * build time — so re-entering a field after a commit shows the
+   * just-saved value.
+   */
+  static inputSubmenu =
+    (
+      theme: Theme,
+      tui: TUI,
+      title: string,
+      message: string,
+      placeholder: string | undefined,
+      validate?: (raw: string) => string | null,
+    ) =>
+    (
+      currentValue: string,
+      done: (selectedValue?: string) => void,
+    ): Component => {
+      const dialog = new InputDialog({
+        theme,
+        tui,
+        title,
+        message,
+        placeholder,
+        initialValue: currentValue,
+        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;
+}

package/src/ui/overrideEntryEditor.ts

@@ -0,0 +1,119 @@
+import type { ModelCost, ModelCostRates } from "@earendil-works/pi-ai";
+import type { LlamaServer, ModelOverride } from "../interfaces/settings";
+
+/**
+ * Parses a raw cost-field value. Empty input means zero (treated as unset
+ * — the key is removed from the settings). Everything else must be a
+ * finite, non-negative number.
+ *
+ * @returns The parsed value, or `null` when the input is invalid
+ */
+export const parseCostValue = (raw: string): number | null => {
+  const v = raw.trim();
+  if (v.length === 0) return 0;
+  const n = Number(v);
+  if (isNaN(n) || !isFinite(n) || n < 0) return null;
+  return n;
+};
+
+/**
+ * Returns a copy of `cost` with `field` set to `value`. A `0` (or
+ * non-finite) value removes the field — unset cost fields default to
+ * zero at read time — and when no fields remain, returns `undefined` so
+ * the whole `cost` object can be dropped. Immutable.
+ */
+export const applyCostFieldValue = (
+  cost: ModelOverride["cost"],
+  field: keyof ModelCostRates,
+  value: number,
+): Partial<ModelCost> | undefined => {
+  const next = { ...cost };
+  if (isFinite(value) && value > 0) next[field] = value;
+  else delete next[field];
+  return Object.keys(next).length > 0 ? next : undefined;
+};
+
+/**
+ * Returns a new list with the server at `serverIndex` updated so its
+ * `overrides` map gains a new `pattern → override` entry. Immutable.
+ */
+export const addOverrideEntry = (
+  servers: LlamaServer[],
+  serverIndex: number,
+  pattern: string,
+  override: ModelOverride = {},
+): LlamaServer[] =>
+  servers.map((server, i) => {
+    if (i !== serverIndex) return server;
+    const overrides = { ...server.overrides, [pattern]: override };
+    return { ...server, overrides };
+  });
+
+/**
+ * Returns a new list with the override entry at `entryIndex` (within the
+ * server's overrides map) replaced by `pattern → override` in a single
+ * mutation — used both for renaming the pattern and for editing its
+ * fields. The entry keeps its position in the map's iteration order.
+ * Immutable.
+ */
+export const updateOverrideEntry = (
+  servers: LlamaServer[],
+  serverIndex: number,
+  entryIndex: number,
+  pattern: string,
+  override: ModelOverride,
+): LlamaServer[] =>
+  servers.map((server, i) => {
+    if (i !== serverIndex) return server;
+    const overrides = server.overrides ?? {};
+    const entries = Object.entries(overrides).map(([k, v], j) =>
+      j === entryIndex ? [pattern, override] : [k, v],
+    );
+    return { ...server, overrides: Object.fromEntries(entries) };
+  });
+
+/**
+ * Returns a new list with the override entry at `entryIndex` (within the
+ * server's overrides map) removed. Immutable.
+ */
+export const removeOverrideEntry = (
+  servers: LlamaServer[],
+  serverIndex: number,
+  entryIndex: number,
+): LlamaServer[] =>
+  servers.map((server, i) => {
+    if (i !== serverIndex) return server;
+    const overrides = server.overrides ?? {};
+    const entries = Object.entries(overrides).filter(
+      (_, j) => j !== entryIndex,
+    );
+    return { ...server, overrides: Object.fromEntries(entries) };
+  });
+
+/**
+ * Formats an override as a summary shown in the entry rows:
+ * `input: $0.2, output: $0.6, cache read: $0.01, capabilities: text,image,
+ * reasoning: false` — cost fields that are zero or undefined are omitted
+ * for brevity; `—` when everything is empty.
+ */
+export const formatOverrideSummary = (override: ModelOverride): string => {
+  const parts: string[] = [];
+  const cost = override.cost ?? {};
+  if (cost.input) parts.push(`input: $${cost.input}`);
+  if (cost.output) parts.push(`output: $${cost.output}`);
+  if (cost.cacheRead) parts.push(`cache read: $${cost.cacheRead}`);
+  if (cost.cacheWrite) parts.push(`cache write: $${cost.cacheWrite}`);
+  if (override.capabilities?.length) {
+    parts.push(`capabilities: ${override.capabilities.join(",")}`);
+  }
+  if (override.reasoning !== undefined) {
+    parts.push(`reasoning: ${override.reasoning}`);
+  }
+  if (override.contextSize !== undefined) {
+    parts.push(`contextSize: ${override.contextSize}`);
+  }
+  if (override.maxTokens !== undefined) {
+    parts.push(`maxTokens: ${override.maxTokens}`);
+  }
+  return parts.length > 0 ? parts.join(", ") : "—";
+};