@0xkahi/pi-qol 0.0.1 → 0.0.2

package/README.md

@@ -3,8 +3,19 @@
 > Quality-of-life extensions for [pi](https://github.com/earendil-works/pi).
 
 A small collection of opt-in extensions that smooth out everyday pi usage. Today
-it ships **`auto_session_name`** — automatic, opencode-style session titling — with
-more QoL features planned.
+it ships **`auto_session_name`** — automatic, opencode-style session titling — and
+**`model_select`** — an interactive model picker.
+
+## Installation
+
+Install the package from npm:
+
+```bash
+pi install npm:@0xkahi/pi-qol
+```
+
+Then register it in your pi configuration so pi loads `./src/index.ts` as an
+extension (see the `pi.extensions` field in `package.json`).
 
 ## Features
 
@@ -23,16 +34,16 @@ never blocks your turn.
 - **Safe output** — strips `<think>` blocks, unwraps quotes, and truncates titles
   to 100 characters.
 
-## Installation
+### `model_select`
 
-Install the package from npm:
+Adds `/select-model`, an interactive model picker with fuzzy search, optional favourites,
+provider filtering, and inline or overlay layouts,
 
-```bash
-pi install npm:@0xkahi/pi-qol
-```
+- **quick access** to listed favourite models
+- **filtering** specified providers from model search 
+
+allow keybindings with [pi-vim-keys](https://github.com/0xKahi/pi-vim-keys) with eventId of `pi.vimKeys.event:pi-qol.model_select`
 
-Then register it in your pi configuration so pi loads `./src/index.ts` as an
-extension (see the `pi.extensions` field in `package.json`).
 
 ## Configuration
 
@@ -44,6 +55,7 @@ them (project overrides global):
 | Global  | `<agent-dir>/extensions/pi-qol/config.json`                |
 | Project | `<cwd>/.pi/extensions/pi-qol/config.json` (trusted projects only) |
 
+
 > Project config is only loaded when the project is trusted.
 
 ### Example
@@ -54,10 +66,16 @@ them (project overrides global):
   "auto_session_name": {
     "enabled": true,
     "model": {
-      "provider": "anthropic",
-      "modelId": "claude-3-5-haiku-latest",
-      "reasoning": "minimal"
+      "provider": "opencode",
+      "modelId": "gpt-5-nano",
+      "reasoning": "low"
     }
+  },
+  "model_select": {
+    "enabled": true,
+    "layout": "overlay",
+    "provider_filter": ["anthropic", "openai"],
+    "favourite": [{ "provider": "anthropic", "modelId": "claude-sonnet-4-5" }]
   }
 }
 ```
@@ -84,6 +102,18 @@ them (project overrides global):
 When `model` is set but cannot be found or authenticated, `pi-qol` automatically
 falls back to the active session model and surfaces a warning notification.
 
+#### `model_select`
+
+| Key               | Type      | Default  | Description                                               |
+| ----------------- | --------- | -------- | --------------------------------------------------------- |
+| `enabled`         | `boolean` | `false`  | Turn the model picker on.                                 |
+| `layout`          | `enum`    | `inline` | Picker layout: `inline` or `overlay`.                     |
+| `provider_filter` | `string[]`| `[]`     | Restrict searchable models to these providers.            |
+| `favourite`       | `object[]`| `[]`     | Favourite models shown in a separate tab (`provider`, `modelId`). |
+
+Project config shallow-merges each top-level section over global config. If project
+config sets `model_select.favourite`, it replaces the global favourites array.
+
 ## How it works
 
 On `before_agent_start`, the `auto_session_name` extension checks a series of

package/assets/config.schema.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "https://raw.githubusercontent.com/0xKahi/pi-qol/main/assets/config.schema.json",
-  "title": "Pi Btw Extension Configuration",
+  "title": "Pi Quality of Life Extensions Configuration",
   "description": "Configuration schema for pi-qol extension",
   "type": "object",
   "properties": {
@@ -51,10 +51,69 @@
         "enabled"
       ],
       "additionalProperties": false
+    },
+    "model_select": {
+      "default": {
+        "enabled": false,
+        "favourite": [],
+        "provider_filter": [],
+        "layout": "inline"
+      },
+      "type": "object",
+      "properties": {
+        "enabled": {
+          "default": false,
+          "type": "boolean"
+        },
+        "favourite": {
+          "default": [],
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "provider": {
+                "type": "string"
+              },
+              "modelId": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "provider",
+              "modelId"
+            ],
+            "additionalProperties": false
+          }
+        },
+        "provider_filter": {
+          "default": [],
+          "type": "array",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          }
+        },
+        "layout": {
+          "default": "inline",
+          "type": "string",
+          "enum": [
+            "inline",
+            "overlay"
+          ]
+        }
+      },
+      "required": [
+        "enabled",
+        "favourite",
+        "provider_filter",
+        "layout"
+      ],
+      "additionalProperties": false
     }
   },
   "required": [
-    "auto_session_name"
+    "auto_session_name",
+    "model_select"
   ],
   "additionalProperties": false
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xkahi/pi-qol",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "quality of life pi extensions",
   "type": "module",
   "keywords": [

package/src/config-loader.ts

@@ -11,10 +11,6 @@ export class ConfigLoader {
     return ConfigSchema.parse({});
   }
 
-  getConfig(): Config {
-    return this.config;
-  }
-
   isEnabled(key: keyof Config): boolean {
     const section = this.config[key];
     return typeof section === 'object' && section !== null && 'enabled' in section ? Boolean((section as { enabled?: boolean }).enabled) : false;
@@ -24,6 +20,10 @@ export class ConfigLoader {
     return this.config.auto_session_name;
   }
 
+  getModelSelect(): Config['model_select'] {
+    return this.config.model_select;
+  }
+
   initializeConfig(ctx: ExtensionContext): { success: boolean; error?: string } {
     let merged: Config = this.defaultConfig;
 

package/src/constants.ts

@@ -1 +1,18 @@
+import type { ObjectValues } from './types';
+
 export const EXTENSION_ID = 'pi-qol';
+
+const SUB_EXTENSION_IDS = {
+  auto_session_name: 'auto_session_name',
+  model_select: 'model_select',
+} as const;
+
+export type SubExtentionIds = ObjectValues<typeof SUB_EXTENSION_IDS>;
+
+export const piVimKeyEventId = (type: SubExtentionIds, extra: string[] = []) => {
+  let id = `pi.vimKeys.event:${EXTENSION_ID}.${type}`;
+  extra.forEach(val => {
+    id = `${id}.${val}`;
+  });
+  return id;
+};

package/src/extensions/auto-session-name/index.ts

@@ -66,7 +66,7 @@ export function registerAutoSessionName(pi: ExtensionAPI, deps: { config: Config
         return;
       }
 
-      ctx.ui.notify(`(pi-qol) auto_session_name: ${result.text}  `, 'info');
+      ctx.ui.notify(`(pi-qol) session renamed  : ${result.text}  `, 'info');
     })().catch(err => {
       ctx.ui.notify(`(pi-qol) auto_session_name: ${JSON.stringify(err)}`, 'error');
     });

package/src/extensions/model-select/constants.ts

@@ -0,0 +1,8 @@
+import { piVimKeyEventId } from '../../constants';
+
+export const COMMAND_NAME = 'select-model';
+export const MAX_VISIBLE_MODELS = 10;
+export const MAX_CONFIG_WARNING_LINES = 4;
+
+// Cross-extension activation hook (for example, pi-vim-keys can emit this to open the picker).
+export const PI_VIM_KEY_EVENT_ID = piVimKeyEventId('model_select');

package/src/extensions/model-select/index.ts

@@ -0,0 +1,119 @@
+import type { Api, Model } from '@earendil-works/pi-ai';
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from '@earendil-works/pi-coding-agent';
+import type { ConfigLoader } from '../../config-loader';
+import { COMMAND_NAME, PI_VIM_KEY_EVENT_ID } from './constants';
+import { ModelFormatter } from './model-formatter';
+import { buildModelLists, findExactModel } from './model-lists';
+import { ModelSelectDialog } from './model-select-dialog';
+import type { DialogResult } from './types';
+
+async function applySelectedModel(pi: ExtensionAPI, ctx: ExtensionContext, model: Model<Api>): Promise<void> {
+  const success = await pi.setModel(model);
+  if (success) {
+    ctx.ui.notify(`Model set to ${ModelFormatter.modelLabel(model)}`, 'info');
+  } else {
+    ctx.ui.notify(`No configured auth for ${ModelFormatter.modelLabel(model)}`, 'error');
+  }
+}
+
+async function showModelSelector(pi: ExtensionAPI, args: string, ctx: ExtensionContext, configLoader: ConfigLoader): Promise<void> {
+  // `waitForIdle` only exists on command contexts. When invoked from the event
+  // bus we get a plain ExtensionContext, so fall back to a best-effort guard.
+  if ('waitForIdle' in ctx && typeof ctx.waitForIdle === 'function') {
+    await (ctx as ExtensionCommandContext).waitForIdle();
+  }
+  ctx.modelRegistry.refresh();
+
+  const exactModel = findExactModel(ctx, args);
+  if (exactModel) {
+    await applySelectedModel(pi, ctx, exactModel);
+    return;
+  }
+
+  if (!ctx.hasUI) {
+    ctx.ui.notify('The /select-model picker requires an interactive UI. Pass provider/modelId to select directly.', 'warning');
+    return;
+  }
+
+  const config = configLoader.getModelSelect();
+  const modelLists = await buildModelLists(ctx, config);
+  const registryError = ctx.modelRegistry.getError();
+
+  const selected = await ctx.ui.custom<DialogResult>(
+    (tui, theme, keybindings, done) =>
+      new ModelSelectDialog(tui, theme, keybindings, {
+        currentModel: ctx.model,
+        favouriteItems: modelLists.favouriteItems,
+        favouriteWarnings: modelLists.favouriteWarnings,
+        hasFavouriteSection: config.favourite.length > 0,
+        searchItems: modelLists.searchItems,
+        providerFilter: config.provider_filter,
+        configWarnings: registryError ? [`models.json: ${registryError}`] : [],
+        initialSearch: args.trim(),
+        layout: config.layout,
+        onDone: done,
+      }),
+    config.layout === 'overlay'
+      ? {
+          overlay: true,
+          overlayOptions: {
+            anchor: 'center',
+            width: '85%',
+            margin: 1,
+          },
+        }
+      : undefined,
+  );
+
+  if (selected) {
+    await applySelectedModel(pi, ctx, selected);
+  }
+}
+
+function activateModelSelect(pi: ExtensionAPI, deps: { config: ConfigLoader; initialCtx?: ExtensionContext }) {
+  // Keep a reference to the latest context so the event-bus handler (which gets
+  // no context of its own) can open the modal too. Lazy activation may happen
+  // during session_start, so seed this with the context that triggered it.
+  let latestCtx: ExtensionContext | undefined = deps.initialCtx;
+
+  pi.on('session_start', (_event, ctx) => {
+    latestCtx = ctx;
+  });
+
+  pi.registerCommand(COMMAND_NAME, {
+    description: 'Select/search models with favourites and provider filtering',
+    handler: async (args, ctx) => {
+      latestCtx = ctx;
+      if (!deps.config.isEnabled('model_select')) {
+        ctx.ui.notify('(pi-qol) model_select is disabled', 'warning');
+        return;
+      }
+      await showModelSelector(pi, args, ctx, deps.config);
+    },
+  });
+
+  // Cross-extension activation: another extension can open the modal via
+  //   pi.events.emit(PI_VIM_KEY_EVENT_ID)
+  pi.events.on(PI_VIM_KEY_EVENT_ID, () => {
+    const ctx = latestCtx;
+    if (!ctx || !deps.config.isEnabled('model_select')) {
+      return;
+    }
+    void showModelSelector(pi, '', ctx, deps.config).catch(error => {
+      ctx.ui.notify(`Failed to open model selector: ${error instanceof Error ? error.message : String(error)}`, 'error');
+    });
+  });
+}
+
+export function registerModelSelect(pi: ExtensionAPI, deps: { config: ConfigLoader }) {
+  let modelSelectRegistered = false;
+
+  pi.on('session_start', (_event, ctx) => {
+    if (!deps.config.isEnabled('model_select') || modelSelectRegistered) {
+      return;
+    }
+
+    activateModelSelect(pi, { config: deps.config, initialCtx: ctx });
+    modelSelectRegistered = true;
+  });
+}

package/src/extensions/model-select/model-formatter.ts

@@ -0,0 +1,60 @@
+import { type Api, type Model, modelsAreEqual } from '@earendil-works/pi-ai';
+import type { ModelItem } from './types';
+
+export class ModelFormatter {
+  static formatTokenCount(count: number): string {
+    if (count >= 1_000_000) {
+      const millions = count / 1_000_000;
+      return millions % 1 === 0 ? `${millions}M` : `${millions.toFixed(1)}M`;
+    }
+    if (count >= 1_000) {
+      const thousands = count / 1_000;
+      return thousands % 1 === 0 ? `${thousands}K` : `${thousands.toFixed(1)}K`;
+    }
+    return count.toString();
+  }
+
+  static modelLabel(model: Model<Api>): string {
+    return `${model.provider}/${model.id}`;
+  }
+
+  static describeModel(model: Model<Api>): string {
+    const capabilities: string[] = [];
+    if (model.reasoning) {
+      capabilities.push('thinking');
+    }
+    if (model.input.includes('image')) {
+      capabilities.push('images');
+    }
+
+    const capabilityText = capabilities.length > 0 ? ` • ${capabilities.join(', ')}` : '';
+    return `${model.name} • ctx ${ModelFormatter.formatTokenCount(model.contextWindow)} • max ${ModelFormatter.formatTokenCount(model.maxTokens)}${capabilityText}`;
+  }
+
+  static toModelItem(model: Model<Api>): ModelItem {
+    return {
+      model,
+      description: ModelFormatter.describeModel(model),
+      searchText: `${model.provider} ${model.id} ${model.provider}/${model.id} ${model.name}`,
+    };
+  }
+
+  static sortModels(models: Model<Api>[], currentModel: Model<Api> | undefined): Model<Api>[] {
+    return [...models].sort((a, b) => {
+      const aIsCurrent = modelsAreEqual(a, currentModel);
+      const bIsCurrent = modelsAreEqual(b, currentModel);
+      if (aIsCurrent && !bIsCurrent) {
+        return -1;
+      }
+      if (!aIsCurrent && bIsCurrent) {
+        return 1;
+      }
+
+      const provider = a.provider.localeCompare(b.provider);
+      if (provider !== 0) {
+        return provider;
+      }
+      return a.id.localeCompare(b.id);
+    });
+  }
+}

package/src/extensions/model-select/model-lists.ts

@@ -0,0 +1,63 @@
+import type { Api, Model } from '@earendil-works/pi-ai';
+import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
+import type { Config } from '../../schemas/config.schema';
+import { ModelFormatter } from './model-formatter';
+import type { ModelItem, ModelLists } from './types';
+
+export async function buildModelLists(ctx: ExtensionContext, config: Config['model_select']): Promise<ModelLists> {
+  ctx.modelRegistry.refresh();
+
+  const availableModels = ctx.modelRegistry.getAvailable();
+  const providerFilterSet = new Set(config.provider_filter);
+  const searchModels = config.provider_filter.length > 0 ? availableModels.filter(model => providerFilterSet.has(model.provider)) : availableModels;
+  const sortedSearchModels = ModelFormatter.sortModels(searchModels, ctx.model).map(model => ModelFormatter.toModelItem(model));
+
+  const favouriteItems: ModelItem[] = [];
+  const favouriteWarnings: string[] = [];
+  const seenFavouriteModels = new Set<string>();
+
+  for (const favourite of config.favourite) {
+    const model = ctx.modelRegistry.find(favourite.provider, favourite.modelId);
+    const label = `${favourite.provider}/${favourite.modelId}`;
+
+    if (!model) {
+      favouriteWarnings.push(`${label} was not found`);
+      continue;
+    }
+
+    if (!ctx.modelRegistry.hasConfiguredAuth(model)) {
+      favouriteWarnings.push(`${label} has no configured auth`);
+      continue;
+    }
+
+    const key = `${model.provider}\u0000${model.id}`;
+    if (seenFavouriteModels.has(key)) {
+      continue;
+    }
+    seenFavouriteModels.add(key);
+    favouriteItems.push(ModelFormatter.toModelItem(model));
+  }
+
+  return { favouriteItems, favouriteWarnings, searchItems: sortedSearchModels };
+}
+
+export function findExactModel(ctx: ExtensionContext, args: string): Model<Api> | undefined {
+  const trimmed = args.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+
+  const slashIndex = trimmed.indexOf('/');
+  if (slashIndex > 0 && slashIndex < trimmed.length - 1) {
+    const provider = trimmed.slice(0, slashIndex).trim();
+    const modelId = trimmed.slice(slashIndex + 1).trim();
+    return ctx.modelRegistry.find(provider, modelId);
+  }
+
+  const [provider, modelId] = trimmed.split(/\s+/, 2);
+  if (provider && modelId) {
+    return ctx.modelRegistry.find(provider, modelId);
+  }
+
+  return undefined;
+}

package/src/extensions/model-select/model-select-dialog.ts

@@ -0,0 +1,340 @@
+import { modelsAreEqual } from '@earendil-works/pi-ai';
+import type { KeybindingsManager, Theme } from '@earendil-works/pi-coding-agent';
+import { type Component, type Focusable, fuzzyFilter, Input, type TUI, truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
+import { MAX_CONFIG_WARNING_LINES, MAX_VISIBLE_MODELS } from './constants';
+import { ModelFormatter } from './model-formatter';
+import type { DialogOptions, ModelItem, SelectionSection } from './types';
+
+function isPrintableInput(data: string): boolean {
+  if (data.length === 0) {
+    return false;
+  }
+  return [...data].every(char => {
+    const code = char.charCodeAt(0);
+    return code >= 32 && code !== 0x7f && (code < 0x80 || code > 0x9f);
+  });
+}
+
+export class ModelSelectDialog implements Component, Focusable {
+  private readonly searchInput = new Input();
+  private activeSection: SelectionSection;
+  private selectedFavouriteIndex = 0;
+  private selectedSearchIndex = 0;
+  private filteredSearchItems: ModelItem[];
+  private _focused = false;
+
+  constructor(
+    private readonly tui: TUI,
+    private readonly theme: Theme,
+    private readonly keybindings: KeybindingsManager,
+    private readonly options: DialogOptions,
+  ) {
+    this.activeSection = options.initialSearch || !options.hasFavouriteSection ? 'search' : 'favourites';
+    const currentFavouriteIndex = options.currentModel
+      ? options.favouriteItems.findIndex(item => modelsAreEqual(item.model, options.currentModel))
+      : -1;
+    this.selectedFavouriteIndex = currentFavouriteIndex >= 0 ? currentFavouriteIndex : 0;
+    this.searchInput.setValue(options.initialSearch);
+    this.searchInput.onSubmit = () => this.selectCurrentSearchItem();
+    this.searchInput.onEscape = () => this.options.onDone(null);
+    this.filteredSearchItems = this.filterSearchItems(options.initialSearch);
+    this.syncFocus();
+  }
+
+  get focused(): boolean {
+    return this._focused;
+  }
+
+  set focused(value: boolean) {
+    this._focused = value;
+    this.syncFocus();
+  }
+
+  invalidate(): void {
+    this.searchInput.invalidate();
+  }
+
+  handleInput(data: string): void {
+    if (this.keybindings.matches(data, 'tui.input.tab')) {
+      this.switchSection();
+      this.tui.requestRender();
+      return;
+    }
+
+    if (this.keybindings.matches(data, 'tui.select.cancel')) {
+      this.options.onDone(null);
+      return;
+    }
+
+    if (this.keybindings.matches(data, 'tui.select.up')) {
+      this.moveSelection(-1);
+      this.tui.requestRender();
+      return;
+    }
+
+    if (this.keybindings.matches(data, 'tui.select.down')) {
+      this.moveSelection(1);
+      this.tui.requestRender();
+      return;
+    }
+
+    if (this.keybindings.matches(data, 'tui.select.pageUp')) {
+      this.moveSelection(-MAX_VISIBLE_MODELS);
+      this.tui.requestRender();
+      return;
+    }
+
+    if (this.keybindings.matches(data, 'tui.select.pageDown')) {
+      this.moveSelection(MAX_VISIBLE_MODELS);
+      this.tui.requestRender();
+      return;
+    }
+
+    if (this.keybindings.matches(data, 'tui.select.confirm')) {
+      this.selectCurrentItem();
+      return;
+    }
+
+    if (this.activeSection !== 'search' && isPrintableInput(data)) {
+      this.activeSection = 'search';
+      this.syncFocus();
+    }
+
+    if (this.activeSection === 'search') {
+      this.searchInput.handleInput(data);
+      this.filteredSearchItems = this.filterSearchItems(this.searchInput.getValue());
+      this.selectedSearchIndex = Math.min(this.selectedSearchIndex, Math.max(0, this.filteredSearchItems.length - 1));
+      this.tui.requestRender();
+    }
+  }
+
+  render(width: number): string[] {
+    const safeWidth = Math.max(3, width);
+
+    if (this.options.layout === 'inline') {
+      const inner = safeWidth;
+      const lines = this.buildContentLines(inner);
+      const rule = this.theme.fg('border', '─'.repeat(inner));
+      const body = lines.map(line => this.padLine(line, inner));
+      return [rule, ...body, rule];
+    }
+
+    const inner = safeWidth - 2;
+    const lines = this.buildContentLines(inner);
+
+    const borderColor = (str: string) => this.theme.fg('border', str);
+    const horizontal = '─'.repeat(inner);
+    const top = borderColor(`╭${horizontal}╮`);
+    const bottom = borderColor(`╰${horizontal}╯`);
+    const side = borderColor('│');
+
+    const wrapped = lines.map(line => `${side}${this.padLine(line, inner)}${side}`);
+    return [top, ...wrapped, bottom];
+  }
+
+  private buildContentLines(inner: number): string[] {
+    const lines: string[] = [];
+
+    lines.push(this.line(this.renderTitle(), inner));
+    lines.push(this.line(this.renderTabs(), inner));
+
+    for (const warning of this.options.configWarnings.slice(0, MAX_CONFIG_WARNING_LINES)) {
+      lines.push(this.line(this.theme.fg('warning', `⚠ ${warning}`), inner));
+    }
+    if (this.options.configWarnings.length > MAX_CONFIG_WARNING_LINES) {
+      lines.push(
+        this.line(this.theme.fg('warning', `⚠ ${this.options.configWarnings.length - MAX_CONFIG_WARNING_LINES} more config warning(s)`), inner),
+      );
+    }
+
+    lines.push('');
+
+    if (this.activeSection === 'favourites') {
+      lines.push(...this.renderFavourites(inner));
+    } else {
+      lines.push(...this.renderSearch(inner));
+    }
+
+    lines.push('');
+    lines.push(this.line(this.renderHelp(), inner));
+
+    return lines;
+  }
+
+  private padLine(text: string, innerWidth: number): string {
+    const truncated = truncateToWidth(text.replace(/[\r\n]+/g, ' '), innerWidth, '');
+    const padding = Math.max(0, innerWidth - visibleWidth(truncated));
+    return truncated + ' '.repeat(padding);
+  }
+
+  private switchSection(): void {
+    if (!this.options.hasFavouriteSection) {
+      this.activeSection = 'search';
+      this.syncFocus();
+      return;
+    }
+
+    this.activeSection = this.activeSection === 'favourites' ? 'search' : 'favourites';
+    this.syncFocus();
+  }
+
+  private syncFocus(): void {
+    this.searchInput.focused = this._focused && this.activeSection === 'search';
+  }
+
+  private moveSelection(delta: number): void {
+    if (this.activeSection === 'favourites') {
+      this.selectedFavouriteIndex = this.wrapIndex(this.selectedFavouriteIndex + delta, this.options.favouriteItems.length);
+      return;
+    }
+
+    this.selectedSearchIndex = this.wrapIndex(this.selectedSearchIndex + delta, this.filteredSearchItems.length);
+  }
+
+  private wrapIndex(index: number, length: number): number {
+    if (length <= 0) {
+      return 0;
+    }
+    return ((index % length) + length) % length;
+  }
+
+  private selectCurrentItem(): void {
+    if (this.activeSection === 'favourites') {
+      const item = this.options.favouriteItems[this.selectedFavouriteIndex];
+      if (item) {
+        this.options.onDone(item.model);
+      }
+      return;
+    }
+
+    this.selectCurrentSearchItem();
+  }
+
+  private selectCurrentSearchItem(): void {
+    const item = this.filteredSearchItems[this.selectedSearchIndex];
+    if (item) {
+      this.options.onDone(item.model);
+    }
+  }
+
+  private filterSearchItems(query: string): ModelItem[] {
+    const trimmed = query.trim();
+    if (!trimmed) {
+      return this.options.searchItems;
+    }
+    return fuzzyFilter(this.options.searchItems, trimmed, item => item.searchText);
+  }
+
+  private renderTitle(): string {
+    const current = this.options.currentModel ? ModelFormatter.modelLabel(this.options.currentModel) : 'none';
+    return `${this.theme.fg('customMessageLabel', this.theme.bold('Select Model'))} ${this.theme.fg('muted', `current: ${current}`)}`;
+  }
+
+  private renderTabs(): string {
+    const tabs: string[] = [];
+    if (this.options.hasFavouriteSection) {
+      tabs.push(this.renderTab('favourites', `Favourites ${this.options.favouriteItems.length}`));
+    }
+    tabs.push(this.renderTab('search', `Search ${this.options.searchItems.length}`));
+    return tabs.join(this.theme.fg('muted', '  '));
+  }
+
+  private renderTab(section: SelectionSection, label: string): string {
+    const text = `[${label}]`;
+    if (this.activeSection === section) {
+      return this.theme.fg('accent', this.theme.bold(text));
+    }
+    return this.theme.fg('muted', text);
+  }
+
+  private renderFavourites(width: number): string[] {
+    const lines: string[] = [];
+
+    if (this.options.favouriteItems.length === 0) {
+      lines.push(this.line(this.theme.fg('muted', '  No configured favourites are available.'), width));
+    } else {
+      lines.push(...this.renderModelList(this.options.favouriteItems, this.selectedFavouriteIndex, width));
+      const selected = this.options.favouriteItems[this.selectedFavouriteIndex];
+      if (selected) {
+        lines.push('');
+        lines.push(this.line(this.theme.fg('muted', `  ${selected.description}`), width));
+      }
+    }
+
+    for (const warning of this.options.favouriteWarnings.slice(0, MAX_CONFIG_WARNING_LINES)) {
+      lines.push(this.line(this.theme.fg('warning', `  ⚠ ${warning}`), width));
+    }
+    if (this.options.favouriteWarnings.length > MAX_CONFIG_WARNING_LINES) {
+      lines.push(
+        this.line(
+          this.theme.fg('warning', `  ⚠ ${this.options.favouriteWarnings.length - MAX_CONFIG_WARNING_LINES} more favourite warning(s)`),
+          width,
+        ),
+      );
+    }
+
+    return lines;
+  }
+
+  private renderSearch(width: number): string[] {
+    const lines: string[] = [];
+    const providerText =
+      this.options.providerFilter.length === 0 ? 'all authorized providers' : `providers: ${this.options.providerFilter.join(', ')}`;
+
+    lines.push(this.line(this.theme.fg('muted', `Provider filter: ${providerText}`), width));
+    lines.push(this.line(this.theme.fg('muted', 'Search query:'), width));
+    lines.push(...this.searchInput.render(width));
+    lines.push('');
+
+    if (this.filteredSearchItems.length === 0) {
+      lines.push(this.line(this.theme.fg('muted', '  No matching models'), width));
+      return lines;
+    }
+
+    lines.push(...this.renderModelList(this.filteredSearchItems, this.selectedSearchIndex, width));
+    const selected = this.filteredSearchItems[this.selectedSearchIndex];
+    if (selected) {
+      lines.push('');
+      lines.push(this.line(this.theme.fg('muted', `  ${selected.description}`), width));
+    }
+
+    return lines;
+  }
+
+  private renderModelList(items: ModelItem[], selectedIndex: number, width: number): string[] {
+    const lines: string[] = [];
+    const startIndex = Math.max(0, Math.min(selectedIndex - Math.floor(MAX_VISIBLE_MODELS / 2), items.length - MAX_VISIBLE_MODELS));
+    const endIndex = Math.min(startIndex + MAX_VISIBLE_MODELS, items.length);
+
+    for (let index = startIndex; index < endIndex; index++) {
+      const item = items[index];
+      if (!item) {
+        continue;
+      }
+      lines.push(this.renderModelItem(item, index === selectedIndex, width));
+    }
+
+    if (startIndex > 0 || endIndex < items.length) {
+      lines.push(this.line(this.theme.fg('dim', `  (${selectedIndex + 1}/${items.length})`), width));
+    }
+
+    return lines;
+  }
+
+  private renderModelItem(item: ModelItem, isSelected: boolean, width: number): string {
+    const currentMark = modelsAreEqual(item.model, this.options.currentModel) ? this.theme.fg('success', ' ✓') : '';
+    const providerBadge = this.theme.fg('muted', `[${item.model.provider}]`);
+    const prefix = isSelected ? this.theme.fg('accent', '→ ') : '  ';
+    const modelText = isSelected ? this.theme.fg('accent', item.model.id) : item.model.id;
+    return this.line(`${prefix}${modelText} ${providerBadge}${currentMark}`, width);
+  }
+
+  private renderHelp(): string {
+    const tabHint = this.options.hasFavouriteSection ? 'tab switch sections • ' : '';
+    return this.theme.fg('dim', `${tabHint}↑↓ navigate • enter select • esc cancel`);
+  }
+
+  private line(text: string, width: number): string {
+    return truncateToWidth(text.replace(/[\r\n]+/g, ' '), Math.max(1, width), '');
+  }
+}

package/src/extensions/model-select/types.ts

@@ -0,0 +1,31 @@
+import type { Api, Model } from '@earendil-works/pi-ai';
+import type { ModelSelectLayout } from '../../schemas/model-select.config.schema';
+
+export type ModelItem = {
+  model: Model<Api>;
+  description: string;
+  searchText: string;
+};
+
+export type ModelLists = {
+  favouriteItems: ModelItem[];
+  favouriteWarnings: string[];
+  searchItems: ModelItem[];
+};
+
+export type SelectionSection = 'favourites' | 'search';
+
+export type DialogResult = Model<Api> | null;
+
+export type DialogOptions = {
+  currentModel: Model<Api> | undefined;
+  favouriteItems: ModelItem[];
+  favouriteWarnings: string[];
+  hasFavouriteSection: boolean;
+  searchItems: ModelItem[];
+  providerFilter: string[];
+  configWarnings: string[];
+  initialSearch: string;
+  layout: ModelSelectLayout;
+  onDone: (result: DialogResult) => void;
+};

package/src/index.ts

@@ -1,6 +1,7 @@
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import { ConfigLoader } from './config-loader';
 import { registerAutoSessionName } from './extensions/auto-session-name';
+import { registerModelSelect } from './extensions/model-select';
 
 export default function (pi: ExtensionAPI) {
   const config = new ConfigLoader();
@@ -11,4 +12,5 @@ export default function (pi: ExtensionAPI) {
   });
 
   registerAutoSessionName(pi, { config });
+  registerModelSelect(pi, { config });
 }

package/src/schemas/auto-session-name.config.schema.ts

@@ -1,9 +1,9 @@
 import z from 'zod';
-import { ModelConfigschema } from './shared-config.schema';
+import { ModelConfigSchema } from './shared-config.schema';
 
 export const AutoSessionNameConfigSchema = z.object({
   enabled: z.boolean().default(false),
-  model: ModelConfigschema.optional(),
+  model: ModelConfigSchema.optional(),
 });
 export type AutoSessionNameConfig = z.infer<typeof AutoSessionNameConfigSchema>;
 

package/src/schemas/config.schema.ts

@@ -1,16 +1,24 @@
 import z from 'zod';
 import { AutoSessionNameConfigSchema, PartialAutoSessionNameConfigSchema } from './auto-session-name.config.schema';
+import { ModelSelectConfigSchema, PartialModelSelectConfigSchema } from './model-select.config.schema';
 
 export const ConfigSchema = z.object({
   $schema: z.string().optional(),
   auto_session_name: AutoSessionNameConfigSchema.default({
     enabled: false,
   }),
+  model_select: ModelSelectConfigSchema.default({
+    enabled: false,
+    favourite: [],
+    provider_filter: [],
+    layout: 'inline',
+  }),
 });
 export type Config = z.infer<typeof ConfigSchema>;
 
 export const PartialConfigSchema = z.object({
   $schema: z.string().optional(),
   auto_session_name: PartialAutoSessionNameConfigSchema.optional(),
+  model_select: PartialModelSelectConfigSchema.optional(),
 });
 export type PartialConfig = z.infer<typeof PartialConfigSchema>;

package/src/schemas/model-select.config.schema.ts

@@ -0,0 +1,18 @@
+import z from 'zod';
+import { ModelConfigSchema } from './shared-config.schema';
+
+const FavouriteModelSchema = ModelConfigSchema.omit({ reasoning: true });
+
+const ModelSelectLayoutSchema = z.enum(['inline', 'overlay']);
+export type ModelSelectLayout = z.infer<typeof ModelSelectLayoutSchema>;
+
+export const ModelSelectConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  favourite: z.array(FavouriteModelSchema).default([]),
+  provider_filter: z.array(z.string().min(1)).default([]),
+  layout: ModelSelectLayoutSchema.default('inline'),
+});
+export type ModelSelectConfig = z.infer<typeof ModelSelectConfigSchema>;
+
+export const PartialModelSelectConfigSchema = ModelSelectConfigSchema.partial();
+export type PartialModelSelectConfig = z.infer<typeof PartialModelSelectConfigSchema>;

package/src/schemas/shared-config.schema.ts

@@ -3,9 +3,9 @@ import z from 'zod';
 export const ReasoningLevelSchema = z.enum(['off', 'minimal', 'low', 'medium', 'high', 'xhigh']);
 export type ReasoningLevel = z.infer<typeof ReasoningLevelSchema>;
 
-export const ModelConfigschema = z.object({
+export const ModelConfigSchema = z.object({
   provider: z.string(),
   modelId: z.string(),
   reasoning: ReasoningLevelSchema,
 });
-export type ModelConfig = z.infer<typeof ModelConfigschema>;
+export type ModelConfig = z.infer<typeof ModelConfigSchema>;

package/src/types.ts

@@ -0,0 +1 @@
+export type ObjectValues<T> = T[keyof T];