pi-llama-cpp 0.13.0 → 0.15.0

package/src/ui/editors/override/fields/cost.ts

@@ -0,0 +1,64 @@
+import type { ModelCost, ModelCostRates } from "@earendil-works/pi-ai";
+import type { ModelOverride } from "../../../../interfaces/settings";
+import type { Field } from "../../../strings";
+import { OverrideEntry } from "../entry";
+import type { InputValidator } from "./base";
+import { OverrideField } from "./base";
+import { parseNonNegative } from "./numeric";
+
+/**
+ * One `ModelCostRates` key of the override's `cost` object (absorbs the
+ * former `CostFieldDefFactory` and the standalone `parseCostValue` /
+ * `applyCostFieldValue` helpers): owns the cost parse and immutable
+ * apply in the same place as its display format.
+ */
+export class CostField extends OverrideField {
+  readonly type = "input";
+  override readonly field: Field;
+
+  constructor(
+    readonly id: string,
+    private readonly key: keyof ModelCostRates,
+    field: Field,
+    /** Short term used in the entry-row summary (e.g. `cache read`). */
+    private readonly summaryTerm: string,
+  ) {
+    super();
+    this.field = field;
+  }
+
+  displayValue(entry: OverrideEntry): string {
+    return String(entry.override.cost?.[this.key] ?? 0);
+  }
+
+  readonly validate: InputValidator = (raw) => {
+    const parsed = parseNonNegative(raw);
+    return parsed === null ? null : String(parsed);
+  };
+
+  apply(override: ModelOverride, value: string): void {
+    const nextCost = this.applyCost(override.cost, Number(value));
+    if (nextCost) override.cost = nextCost;
+    else delete override.cost;
+  }
+
+  /** Returns a copy of `cost` with this 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. */
+  private applyCost(
+    cost: ModelOverride["cost"],
+    value: number,
+  ): Partial<ModelCost> | undefined {
+    const next = { ...cost };
+    if (isFinite(value) && value > 0) next[this.key] = value;
+    else delete next[this.key];
+    return Object.keys(next).length > 0 ? next : undefined;
+  }
+
+  /** Appears in the summary only when a non-zero cost is set. */
+  override summaryPart(override: ModelOverride): string | null {
+    const value = override.cost?.[this.key];
+    return value ? `${this.summaryTerm}: $${value}` : null;
+  }
+}

package/src/ui/editors/override/fields/index.ts

@@ -0,0 +1,68 @@
+import type { ModelCostRates } from "@earendil-works/pi-ai";
+import type { ModelOverride } from "../../../../interfaces/settings";
+import { FIELDS } from "../../../strings";
+import { OverrideField } from "./base";
+import { CapabilitiesField } from "./capabilities";
+import { CostField } from "./cost";
+import { NumericField } from "./numeric";
+import { PatternField } from "./pattern";
+import { ReasoningField } from "./reasoning";
+
+/** Cost field specs: [ModelCostRates key, FIELDS entry, summary term] */
+const COST_FIELDS: [
+  keyof ModelCostRates,
+  (
+    | typeof FIELDS.inputCost
+    | typeof FIELDS.outputCost
+    | typeof FIELDS.cacheReadCost
+    | typeof FIELDS.cacheWriteCost
+  ),
+  string,
+][] = [
+  ["input", FIELDS.inputCost, "input"],
+  ["output", FIELDS.outputCost, "output"],
+  ["cacheRead", FIELDS.cacheReadCost, "cache read"],
+  ["cacheWrite", FIELDS.cacheWriteCost, "cache write"],
+];
+
+/**
+ * The field registry for model override entries: the complete list of
+ * editable fields (order defines the row order in the settings list)
+ * plus id-based lookup. Throws on an unknown id — the registry is
+ * static, so a miss is a programming error.
+ */
+export class OverrideFields {
+  static readonly all: OverrideField[] = [
+    new PatternField(),
+    ...COST_FIELDS.map(
+      ([key, field, term]) => new CostField(`cost.${key}`, key, field, term),
+    ),
+    new CapabilitiesField(),
+    new ReasoningField(),
+    new NumericField("contextSize", FIELDS.contextSize),
+    new NumericField("maxTokens", FIELDS.maxTokens),
+  ];
+
+  static byId(id: string): OverrideField {
+    const field = this.all.find((f) => f.id === id);
+    if (!field) throw new Error(`Unknown override field: ${id}`);
+    return field;
+  }
+}
+
+/**
+ * Builds the entry-row summary shown in the override entry list
+ * (`input: $0.2, output: $0.6, cache read: $0.01, …`), composed from the
+ * {@link OverrideFields} registry — adding a field to the registry makes
+ * it show up here too, so the summary can't lag the edit menu. Fields
+ * with unset/zero values are omitted for brevity (each field decides via
+ * {@link OverrideField.summaryPart}); `—` when nothing is set.
+ */
+export class OverrideSummary {
+  static of(override: ModelOverride): string {
+    const parts = OverrideFields.all
+      .map((field) => field.summaryPart(override))
+      .filter((part): part is string => part !== null);
+    return parts.length > 0 ? parts.join(", ") : "—";
+  }
+}

package/src/ui/editors/override/fields/numeric.ts

@@ -0,0 +1,55 @@
+import type { ModelOverride } from "../../../../interfaces/settings";
+import type { Field } from "../../../strings";
+import { OverrideEntry } from "../entry";
+import type { InputValidator } from "./base";
+import { OverrideField } from "./base";
+
+/** Parses a non-negative number; blank input means zero (unset fields
+ * default to zero at read time). Returns `null` when invalid. */
+export function parseNonNegative(raw: string): number | null {
+  const n = Number(raw.trim());
+  return isFinite(n) && n >= 0 ? n : null;
+}
+
+/**
+ * Non-negative numeric field (`contextSize`, `maxTokens`): keeps the
+ * display format, validator and apply logic in a single place so the
+ * three can't drift (e.g. the validator accepting `0` while the apply
+ * drops it — unset fields default to zero at read time, so all render
+ * as `0`).
+ */
+export class NumericField extends OverrideField {
+  readonly type = "input";
+  override readonly field: Field;
+
+  constructor(
+    readonly id: "maxTokens" | "contextSize",
+    field: Field,
+  ) {
+    super();
+    this.field = field;
+  }
+
+  displayValue(entry: OverrideEntry): string {
+    return String(entry.override[this.id] ?? 0);
+  }
+
+  /** Accepts finite, non-negative numbers (blank means zero). */
+  readonly validate: InputValidator = (raw) => {
+    const n = parseNonNegative(raw);
+    return n === null ? null : String(n);
+  };
+
+  /** Applies the committed value; non-positive values remove the key. */
+  apply(override: ModelOverride, value: string): void {
+    const n = Number(value);
+    if (isFinite(n) && n > 0) override[this.id] = n;
+    else delete override[this.id];
+  }
+
+  /** Appears in the summary only when set. */
+  override summaryPart(override: ModelOverride): string | null {
+    const value = override[this.id];
+    return value === undefined ? null : `${this.id}: ${value}`;
+  }
+}

package/src/ui/editors/override/fields/pattern.ts

@@ -0,0 +1,24 @@
+import { FIELDS } from "../../../strings";
+import { OverrideEntry } from "../entry";
+import type { InputValidator } from "./base";
+import { OverrideField } from "./base";
+
+/**
+ * The entry's pattern key. Renames are handled by the editor
+ * (`OverrideEntryListEditor.applyFieldChange`), so {@link apply}
+ * inherits the base no-op.
+ */
+export class PatternField extends OverrideField {
+  readonly id = "pattern";
+  readonly type = "input";
+  readonly field = FIELDS.pattern;
+
+  displayValue(entry: OverrideEntry): string {
+    return entry.pattern;
+  }
+
+  readonly validate: InputValidator = (raw) => {
+    const trimmed = raw.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  };
+}

package/src/ui/editors/override/fields/reasoning.ts

@@ -0,0 +1,33 @@
+import type { ModelOverride } from "../../../../interfaces/settings";
+import { FIELDS } from "../../../strings";
+import { OverrideEntry } from "../entry";
+import type { InputValidator } from "./base";
+import { OverrideField } from "./base";
+
+/** The override's `reasoning` flag (finite: true/false, default true). */
+export class ReasoningField extends OverrideField {
+  readonly id = "reasoning";
+  readonly type = "finite";
+  readonly field = FIELDS.reasoning;
+  override readonly options = ["true", "false"];
+
+  displayValue(entry: OverrideEntry): string {
+    return entry.override.reasoning === false ? "false" : "true";
+  }
+
+  readonly validate: InputValidator = (raw) =>
+    this.options?.includes(raw) ? raw : null;
+
+  apply(override: ModelOverride, value: string): void {
+    if (value === "true") override.reasoning = true;
+    else if (value === "false") override.reasoning = false;
+    else delete override.reasoning;
+  }
+
+  /** Appears in the summary only when explicitly set. */
+  override summaryPart(override: ModelOverride): string | null {
+    return override.reasoning === undefined
+      ? null
+      : `reasoning: ${override.reasoning}`;
+  }
+}

package/src/ui/editors/override/itemBuilder.ts

@@ -0,0 +1,39 @@
+import type { SettingItem } from "@earendil-works/pi-tui";
+import { FieldMessages, TITLES } from "../../strings";
+import { ItemBuilder } from "../itemBuilder";
+import { OverrideEntry } from "./entry";
+import type { OverrideField } from "./fields/base";
+import { OverrideFields } from "./fields/index";
+
+/**
+ * Builds `SettingItem` objects for override entry field submenus.
+ */
+export class OverrideItemBuilder extends ItemBuilder<
+  OverrideEntry,
+  OverrideField
+> {
+  protected get fields(): readonly OverrideField[] {
+    return OverrideFields.all;
+  }
+
+  /**
+   * Adds field-type-specific columns: fixed `values` for "finite" fields,
+   * an `InputDialog` submenu (validating against the field definition)
+   * for "input" fields.
+   */
+  protected decorate(def: OverrideField, base: SettingItem): SettingItem {
+    if (def.type === "finite") {
+      return { ...base, values: [...(def.options ?? [])] };
+    }
+
+    return {
+      ...base,
+      submenu: this.dialogs.inputSubmenu(
+        TITLES.edit(def.label),
+        FieldMessages.of(def.field),
+        def.placeholder,
+        def.validate,
+      ),
+    };
+  }
+}

package/src/ui/editors/override/overrideList.ts

@@ -0,0 +1,127 @@
+import type { ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+import type {
+  Component,
+  Focusable,
+  SettingItem,
+  SettingsList,
+} from "@earendil-works/pi-tui";
+import type { LlamaServer } from "../../../interfaces/settings";
+import type { LlamaSettingsManager } from "../../../managers/settings";
+import { HINTS } from "../../strings";
+import type { OverrideSettingsListOptions } from "../editorOptions";
+import { SettingsListFactory } from "../settingsListFactory";
+import { OverrideEntryListEditor } from "./entryEditor";
+
+/**
+ * Top-level overrides editor: one row per server, Enter drills into
+ * override entries.
+ *
+ * Unlike `ServerSettingsList`, this has no add/delete — just drill-down.
+ *
+ * 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`.
+ */
+export class OverrideSettingsList implements Component, Focusable {
+  private settingsList: SettingsList | null = null;
+  private isFocused = false;
+
+  constructor(private readonly options: OverrideSettingsListOptions) {
+    this.settingsList = this.buildSettingsList();
+  }
+
+  /**
+   * Opens the editor in a modal `ui.custom` dialog seeded with the
+   * current `llamaSettings.servers` and resolves when the user closes
+   * it (Esc). Writes go through `settings.setLlamaSetting()`; write
+   * errors are notified via `ui` and the editor stays open with the
+   * pre-mutation list.
+   */
+  static async show(
+    ui: ExtensionUIContext,
+    settings: LlamaSettingsManager,
+  ): Promise<void> {
+    const servers = await settings.getLlamaServers();
+
+    await ui.custom<void>(
+      (tui, theme, keybindings, done) =>
+        new OverrideSettingsList({
+          tui,
+          theme,
+          keybindings,
+          servers,
+          persist: (next) => settings.setLlamaSetting("servers", next),
+          done: () => done(undefined),
+          onError: (message) => ui.notify(message, "error"),
+          onChanged: () => {}, // no per-change notification needed
+        }),
+    );
+  }
+
+  // -- Component -------------------------------------------------------------
+
+  invalidate(): void {
+    this.settingsList?.invalidate();
+  }
+
+  handleInput(data: string): void {
+    this.settingsList?.handleInput(data);
+  }
+
+  render(width: number): string[] {
+    if (!this.settingsList) return ["Loading..."];
+    return this.settingsList.render(width);
+  }
+
+  // -- Focusable -------------------------------------------------------------
+
+  get focused(): boolean {
+    return this.isFocused;
+  }
+
+  set focused(value: boolean) {
+    // `SettingsList` has no `focused` flag — the flag is ours alone
+    this.isFocused = value;
+  }
+
+  // -- internal --------------------------------------------------------------
+
+  private buildSettingsList(): SettingsList {
+    const serverItems: SettingItem[] = this.options.servers.map(
+      (server, i) => ({
+        id: `server-${i}`,
+        label: server.url,
+        description: HINTS.overrideServerRow,
+        currentValue: OverrideSettingsList.entriesLabel(server),
+        submenu: (_cv, done) =>
+          new OverrideEntryListEditor(this.options, i, () => {
+            // Entry count may have changed (add/delete/pattern rename)
+            const current = this.options.servers[i];
+            serverList?.updateValue(
+              `server-${i}`,
+              OverrideSettingsList.entriesLabel(current),
+            );
+            done();
+          }),
+      }),
+    );
+
+    let serverList: SettingsList | null = null;
+    serverList = SettingsListFactory.create(serverItems, () => {
+      this.options.done();
+    });
+    return serverList;
+  }
+
+  /** Row summary for a server in the list: its override entry count. */
+  private static entriesLabel(server: LlamaServer | undefined): string {
+    return `${Object.keys(server?.overrides ?? {}).length} entries`;
+  }
+}

package/src/ui/editors/server/builder.ts

@@ -0,0 +1,60 @@
+import type { LlamaServer } from "../../../interfaces/settings";
+
+/**
+ * Builder for `LlamaServer` objects, centralizing the "empty string means
+ * omit the key" rule for the optional `id` and `name` fields — the single
+ * place where that invariant lives, shared by the add-server wizard's
+ * final step and by field commits on existing servers.
+ *
+ * Start from an existing server with {@link from}, chain the setters,
+ * then call {@link build}. Immutable with respect to the input: the
+ * source server is never mutated.
+ */
+export class LlamaServerBuilder {
+  private constructor(private data: LlamaServer) {}
+
+  /** Starts a builder from an existing server (also used to start a
+   * fresh `{ url }` server in the wizard flow). */
+  static from(server: LlamaServer): LlamaServerBuilder {
+    return new LlamaServerBuilder({ ...server });
+  }
+
+  /** Sets the URL (always present, never omitted). */
+  url(url: string): this {
+    this.data = { ...this.data, url };
+    return this;
+  }
+
+  /**
+   * Sets the custom provider ID. An empty value omits the key — when
+   * editing an existing server this removes it, restoring the
+   * URL-based auto-detected ID.
+   */
+  optionalId(id: string): this {
+    this.data = this.withOptional("id", id);
+    return this;
+  }
+
+  /**
+   * Sets the display name. An empty value omits the key — when editing
+   * an existing server this removes it.
+   */
+  optionalName(name: string): this {
+    this.data = this.withOptional("name", name);
+    return this;
+  }
+
+  /** Returns the built server. */
+  build(): LlamaServer {
+    return this.data;
+  }
+
+  /** Copies `data`, setting `key` to `value` when non-empty and
+   * removing the key otherwise. */
+  private withOptional(key: "id" | "name", value: string): LlamaServer {
+    const next = { ...this.data };
+    if (value.length > 0) next[key] = value;
+    else delete next[key];
+    return next;
+  }
+}

package/src/ui/editors/server/fields.ts

@@ -0,0 +1,84 @@
+import type { LlamaServer } from "../../../interfaces/settings";
+import { ServerUrl } from "../../../utils/urls";
+import { FIELDS, type Field } from "../../strings";
+import { SettingField } from "../settingField";
+import { LlamaServerBuilder } from "./builder";
+
+/**
+ * Base class for one editable field of a server row. `apply` delegates
+ * to {@link LlamaServerBuilder} so the unset-on-empty rule for `id`/
+ * `name` stays in one place. Mirrors the override side's
+ * `OverrideField`.
+ */
+export abstract class ServerField extends SettingField<LlamaServer> {
+  /** Validation function for committed values (`undefined` = accept
+   * any). */
+  readonly validate: ((raw: string) => string | null) | undefined = undefined;
+
+  /** Applies a committed value to the server, immutably (returns the
+   * updated copy). */
+  abstract apply(server: LlamaServer, value: string): LlamaServer;
+}
+
+/** The server URL (required, validated). */
+class UrlField extends ServerField {
+  readonly id = "url";
+  readonly field = FIELDS.serverUrl;
+  readonly validate = ServerUrl.parse;
+
+  currentValue(server: LlamaServer): string {
+    return server.url;
+  }
+
+  apply(server: LlamaServer, value: string): LlamaServer {
+    return LlamaServerBuilder.from(server).url(value).build();
+  }
+}
+
+/**
+ * An optional string field (`id`, `name`). Empty input omits the key —
+ * when editing an existing server this removes it, restoring the
+ * URL-based auto-detected id for `id`.
+ */
+class OptionalTextField extends ServerField {
+  readonly field: Field;
+
+  constructor(
+    readonly id: "id" | "name",
+    field: Field,
+  ) {
+    super();
+    this.field = field;
+  }
+
+  currentValue(server: LlamaServer): string {
+    return server[this.id] ?? "";
+  }
+
+  apply(server: LlamaServer, value: string): LlamaServer {
+    const builder = LlamaServerBuilder.from(server);
+    return this.id === "id"
+      ? builder.optionalId(value).build()
+      : builder.optionalName(value).build();
+  }
+}
+
+/**
+ * The field registry for servers: the complete list of editable fields
+ * (order defines the row order in the settings list) plus id-based
+ * lookup. Throws on an unknown id — the registry is static, so a miss is
+ * a programming error.
+ */
+export class ServerFields {
+  static readonly all: readonly ServerField[] = [
+    new UrlField(),
+    new OptionalTextField("id", FIELDS.providerId),
+    new OptionalTextField("name", FIELDS.displayName),
+  ];
+
+  static byId(id: string): ServerField {
+    const field = this.all.find((f) => f.id === id);
+    if (!field) throw new Error(`Unknown server field: ${id}`);
+    return field;
+  }
+}

package/src/ui/editors/server/itemBuilder.ts

@@ -0,0 +1,64 @@
+import type { SettingItem } from "@earendil-works/pi-tui";
+import type { LlamaServer } from "../../../interfaces/settings";
+import { FieldMessages, HINTS, TITLES } from "../../strings";
+import { ItemBuilder } from "../itemBuilder";
+import { SettingsListFactory } from "../settingsListFactory";
+import { ServerFields, type ServerField } from "./fields";
+import { ServerDisplay } from "./utils";
+
+/**
+ * Builds `SettingItem` objects for server rows and their field-edit submenus.
+ */
+export class ServerItemBuilder extends ItemBuilder<LlamaServer, ServerField> {
+  protected get fields(): readonly ServerField[] {
+    return ServerFields.all;
+  }
+
+  /**
+   * Adds the field-edit submenu: an `InputDialog` validating against the
+   * field definition.
+   */
+  protected decorate(def: ServerField, base: SettingItem): SettingItem {
+    return {
+      ...base,
+      submenu: this.dialogs.inputSubmenu(
+        TITLES.edit(def.label),
+        FieldMessages.of(def.field),
+        def.placeholder,
+        def.validate,
+      ),
+    };
+  }
+
+  /**
+   * Builds the `SettingItem` for one server row in the top-level list.
+   * Enter drills into the server's field-edit submenu.
+   */
+  buildRow(
+    server: LlamaServer,
+    index: number,
+    onChange: (field: string, value: string) => void,
+    healthEmoji: string,
+    onSubmenuChange: (open: boolean) => void,
+  ): SettingItem {
+    return {
+      id: `server-${index}`,
+      label: `${healthEmoji} ${server.url}`,
+      description: HINTS.serverRow,
+      currentValue: ServerDisplay.suffix(server),
+      submenu: (_cv, done) => {
+        // Rebuild the field items on open so they prefill with current values
+        const items = this.buildFieldItems(server);
+        onSubmenuChange(true);
+        return SettingsListFactory.create(
+          items,
+          () => {
+            onSubmenuChange(false);
+            done();
+          },
+          onChange,
+        );
+      },
+    };
+  }
+}