@hieplp/pi-account-switcher 0.2.0

package/src/commands/accounts/remove.ts

@@ -0,0 +1,40 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import type { AccountSwitcherContext } from "@/types";
+import { COMMANDS } from "@/constants";
+import { errorUtil } from "@/utils";
+import { AccountCommand } from "./shared";
+
+export const useRemoveAccountCommand = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
+  new RemoveAccountCommand(pi, runtime).register();
+};
+
+class RemoveAccountCommand extends AccountCommand {
+  constructor(pi: ExtensionAPI, runtime: AccountSwitcher) {
+    super(pi, runtime, COMMANDS.accounts.remove);
+  }
+
+  async handler(ctx: AccountSwitcherContext): Promise<void> {
+    try {
+      const accounts = await this.loadAccounts(ctx);
+      if (!accounts) return;
+
+      const removable = accounts.filter((a) => !this.isActiveAccount(a));
+      if (removable.length === 0) {
+        ctx.ui.notify("No removable accounts. Switch to another account first.", "info");
+        return;
+      }
+
+      const account = await this.pickGroupedAccount(ctx, removable, "Select account to remove");
+      if (!account) return;
+
+      const confirmed = await ctx.ui.confirm("Remove account?", `"${account.label}" will be permanently removed.`);
+      if (!confirmed) return;
+
+      await this.runtime.removeAccount(account);
+      ctx.ui.notify(`Account "${account.label}" removed.`, "info");
+    } catch (e) {
+      ctx.ui.notify(`Failed to remove account: ${errorUtil.format(e)}`, "error");
+    }
+  }
+}

package/src/commands/accounts/shared/base.ts

@@ -0,0 +1,88 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import type { AccountConfig, AccountSwitcherContext } from "@/types";
+import { uiUtil } from "@/utils";
+import { BaseCommand, type CommandMeta } from "../../base";
+import { buildGroupedItems, formatAccountItem } from "./select";
+
+const DUPLICATE_ID_OPTIONS = {
+  replace: "Replace existing account",
+  newId: "Enter a new id",
+  cancel: "Cancel",
+} as const;
+
+export abstract class AccountCommand extends BaseCommand {
+  constructor(pi: ExtensionAPI, runtime: AccountSwitcher, meta: CommandMeta) {
+    super(pi, runtime, meta);
+  }
+
+  protected async loadAccounts(ctx: AccountSwitcherContext): Promise<AccountConfig[] | undefined> {
+    await this.runtime.load();
+    const accounts = this.runtime.getAccounts();
+    if (accounts.length === 0) {
+      ctx.ui.notify("No accounts configured.", "info");
+      return undefined;
+    }
+    return accounts;
+  }
+
+  protected async loadAndSelectAccount(ctx: AccountSwitcherContext, label: string): Promise<AccountConfig | undefined> {
+    const accounts = await this.loadAccounts(ctx);
+    if (!accounts) return undefined;
+    return this.pickGroupedAccount(ctx, accounts, label);
+  }
+
+  protected async saveAccount(ctx: AccountSwitcherContext, account: AccountConfig): Promise<AccountConfig | undefined> {
+    let candidate = account;
+    while (true) {
+      const existing = this.runtime.findAccountById(candidate.id);
+      if (!existing) {
+        await this.runtime.addAccount(candidate);
+        return candidate;
+      }
+
+      const action = await ctx.ui.select(`Account id already exists: ${candidate.id}`, [
+        DUPLICATE_ID_OPTIONS.replace,
+        DUPLICATE_ID_OPTIONS.newId,
+        DUPLICATE_ID_OPTIONS.cancel,
+      ]);
+
+      if (DUPLICATE_ID_OPTIONS.replace === action) {
+        await this.runtime.editAccount(existing, candidate);
+        return candidate;
+      }
+
+      if (DUPLICATE_ID_OPTIONS.newId === action) {
+        const prompt = uiUtil.prompt(ctx.ui);
+        const nextId = await prompt("New account id", `${candidate.id}-2`).asText();
+        if (!nextId) return undefined;
+        candidate = { ...candidate, id: nextId };
+        continue;
+      }
+
+      return undefined;
+    }
+  }
+
+  protected async pickGroupedAccount(
+    ctx: AccountSwitcherContext,
+    accounts: AccountConfig[],
+    label = "Pick account",
+  ): Promise<AccountConfig | undefined> {
+    const items = buildGroupedItems(accounts, this.runtime.getProviders(), this.runtime.getActiveAccount()?.id);
+
+    const labels: string[] = [];
+    const values: Array<AccountConfig | null> = [];
+    for (const item of items) {
+      if (item.type === "header") {
+        labels.push(item.provider);
+        values.push(null);
+        continue;
+      }
+      labels.push(formatAccountItem(item));
+      values.push(item.account);
+    }
+
+    return this.pickGrouped(ctx, label, labels, values);
+  }
+}

package/src/commands/accounts/shared/index.ts

@@ -0,0 +1,3 @@
+export * from "./prompts";
+export * from "./base";
+export * from "./select";

package/src/commands/accounts/shared/prompts.ts

@@ -0,0 +1,226 @@
+import type { ExtensionUIContext } from "@mariozechner/pi-coding-agent";
+import type { AccountConfig, ProviderConfig, SecretSource } from "@/types";
+import { commonUtil, providerUtil, uiUtil } from "@/utils";
+import { ACCOUNTS_PATH } from "@/constants";
+
+export const SECRET_SOURCE_CHOICES = {
+  literal: "Paste API key now (stored in config)",
+  env: "Read from existing environment variable",
+  file: "Read from file",
+  command: "Run shell command",
+  op: "1Password op reference",
+} as const;
+
+const SECRET_SOURCE_CHOICE_LABELS = Object.values(SECRET_SOURCE_CHOICES);
+
+const LABEL_TO_SOURCE_TYPE = new Map(
+  (Object.entries(SECRET_SOURCE_CHOICES) as [keyof typeof SECRET_SOURCE_CHOICES, string][]).map(([k, v]) => [v, k]),
+);
+
+export class AccountConfigBuilder {
+  private readonly prompt: ReturnType<typeof uiUtil.prompt>;
+  private config: Partial<AccountConfig> = {};
+  private customProvider?: ProviderConfig;
+
+  constructor(
+    private readonly ui: ExtensionUIContext,
+    private readonly customProviders: ProviderConfig[] = [],
+    original?: Partial<AccountConfig>,
+  ) {
+    this.prompt = uiUtil.prompt(ui);
+    if (original) {
+      this.config = { ...original };
+      if (original.provider) {
+        this.customProvider = providerUtil.findProvider(original.provider, customProviders);
+      }
+    }
+  }
+
+  async withProvider(): Promise<this> {
+    const choice = await uiUtil.filteredSelect(this.ui, "Provider", providerUtil.providerChoices(this.customProviders));
+    if (!choice) return this;
+
+    const raw = choice === "custom" ? await this.prompt("Custom provider", "provider-id").asText() : choice;
+    const provider = providerUtil.normalizeProvider(raw ?? "");
+    if (!provider) throw new Error("Provider is required");
+
+    this.config.provider = provider;
+    this.customProvider = providerUtil.findProvider(provider, this.customProviders);
+
+    return this;
+  }
+
+  async withLabel(): Promise<this> {
+    const hint = this.config.label ?? `${this.config.provider ?? ""} — Work`;
+    const label = await this.prompt("Account label", hint).asText();
+    if (!label) {
+      if (!this.config.label) throw new Error("Account label is required");
+      return this;
+    }
+    this.config.label = label;
+
+    return this;
+  }
+
+  async withId(): Promise<this> {
+    const suggested = commonUtil.slugify(this.config.label ?? "");
+    const hint = this.config.id ?? suggested;
+    const id = (await this.prompt("Account id", hint).asText()) || hint;
+    if (!id) {
+      throw new Error("Account id is required");
+    }
+    this.config.id = id;
+
+    return this;
+  }
+
+  async withModel(): Promise<this> {
+    if (!this.customProvider) {
+      return this;
+    }
+
+    const modelIds = (this.customProvider.models ?? []).map((m) => m.id);
+    if (modelIds.length === 0) {
+      this.config.model = await this.prompt("Default model for this account (optional)", this.config.model).asText();
+      return this;
+    }
+
+    const choice = await uiUtil.filteredSelect(this.ui, "Default model for this account", [
+      "Use current model",
+      ...modelIds,
+      "custom",
+    ]);
+    if (!choice || choice === "Use current model") return this;
+
+    this.config.model = choice === "custom" ? await this.prompt("Model id", modelIds[0]).asText() : choice;
+
+    return this;
+  }
+
+  async withCredentials(): Promise<this> {
+    const { provider } = this.config;
+    if (!provider) return this;
+
+    if (this.customProvider) {
+      const apiKey = await this.promptForCustomProviderApiKey(this.customProvider);
+      if (apiKey || this.customProvider.apiKey) {
+        if (apiKey) {
+          this.config.providerApiKey = apiKey;
+        } else {
+          this.config.usesProviderApiKey = true;
+        }
+        return this;
+      }
+    }
+
+    const envKeys = providerUtil.requiredEnvKeysForProvider(provider, this.customProviders);
+    const envChoice = await this.ui.select("Credential env var", [...envKeys, "custom"]);
+    if (!envChoice) return this;
+
+    const envName = envChoice === "custom" ? await this.prompt("Env var name", "PROVIDER_API_KEY").asText() : envChoice;
+    if (!envName) throw new Error("Env var name is required");
+
+    const sourceLabel = await this.ui.select("How should Pi load this credential?", SECRET_SOURCE_CHOICE_LABELS);
+    if (!sourceLabel) return this;
+
+    const sourceType = LABEL_TO_SOURCE_TYPE.get(sourceLabel);
+    if (!sourceType) return this;
+
+    const source = await this.promptForSecretSource(sourceType);
+    if (source) {
+      this.config.env = { ...this.config.env, [envName]: source };
+    }
+
+    return this;
+  }
+
+  build(): AccountConfig {
+    const { id, label, provider } = this.config;
+    if (!id || !label || !provider) throw new Error("Account id, label, and provider are required");
+
+    return {
+      id,
+      label,
+      provider,
+      ...(this.config.model ? { model: this.config.model } : {}),
+      ...(this.config.env ? { env: this.config.env } : {}),
+      ...(this.config.providerApiKey ? { providerApiKey: this.config.providerApiKey } : {}),
+      ...(this.config.usesProviderApiKey ? { usesProviderApiKey: true } : {}),
+      ...(this.config.piAuth ? { piAuth: this.config.piAuth } : {}),
+    };
+  }
+
+  async collect(): Promise<AccountConfig | undefined> {
+    await this.withProvider();
+    if (!this.config.provider) return undefined;
+
+    await this.withLabel();
+    await this.withId();
+    await this.withModel();
+    await this.withCredentials();
+
+    if (!this.config.env && !this.config.providerApiKey && !this.config.usesProviderApiKey && !this.config.piAuth) {
+      this.ui.notify("No credentials configured. Account not saved.", "info");
+      return undefined;
+    }
+
+    return this.build();
+  }
+
+  private async promptForSecretSource(type: keyof typeof SECRET_SOURCE_CHOICES): Promise<SecretSource | undefined> {
+    switch (type) {
+      case "literal": {
+        const ok = await this.ui.confirm(
+          "Store API key in config?",
+          `This will write the API key to ${ACCOUNTS_PATH} as plain text. Continue?`,
+        );
+        if (!ok) return undefined;
+
+        const value = await this.prompt("API key", "sk-...").asText();
+        if (!value) throw new Error("API key is required");
+
+        return { type: "literal", value };
+      }
+      case "env": {
+        const name = await this.prompt("Source environment variable", "MY_API_KEY").asText();
+        if (!name) throw new Error("Source environment variable is required");
+
+        return { type: "env", name };
+      }
+      case "file": {
+        const path = await this.prompt("Secret file path", "~/.keys/provider-account.txt").asText();
+        if (!path) throw new Error("File path is required");
+
+        return { type: "file", path };
+      }
+      case "command": {
+        const command = await this.prompt("Command", "op read op://AI/Account/api-key").asText();
+        if (!command) throw new Error("Command is required");
+
+        return { type: "command", command };
+      }
+      case "op": {
+        const reference = await this.prompt("1Password reference", "op://AI/Account/api-key").asText();
+        if (!reference) throw new Error("1Password reference is required");
+
+        return { type: "op", reference };
+      }
+    }
+  }
+
+  private async promptForCustomProviderApiKey(provider: ProviderConfig): Promise<SecretSource | undefined> {
+    if (!provider.baseUrl && !provider.models?.length && !provider.apiKey) {
+      return undefined;
+    }
+
+    const hint = provider.apiKey ? "blank = provider apiKey" : "sk-...";
+    const value = await this.prompt("Account API key override (blank uses provider apiKey)", hint).asText();
+    if (!value) return undefined;
+
+    const ok = await this.ui.confirm(
+      "Store API key in account config?",
+      `This will write the API key to ${ACCOUNTS_PATH} as plain text. Continue?`,
+    );
+    return ok ? { type: "literal", value } : undefined;
+  }
+}

package/src/commands/accounts/shared/select.ts

@@ -0,0 +1,37 @@
+import type { AccountConfig, ProviderConfig } from "@/types";
+import { providerUtil } from "@/utils";
+
+export type GroupedAccountItem =
+  | { type: "header"; provider: string }
+  | { type: "account"; account: AccountConfig; provider: string; active: boolean };
+
+export function buildGroupedItems(
+  accounts: AccountConfig[],
+  providers: ProviderConfig[],
+  activeId: string | undefined,
+): GroupedAccountItem[] {
+  const sorted = [...accounts].sort((a, b) => {
+    const pa = providerUtil.normalizeProviderWithCustom(a.provider, providers);
+    const pb = providerUtil.normalizeProviderWithCustom(b.provider, providers);
+    return pa.localeCompare(pb) || a.label.localeCompare(b.label);
+  });
+
+  const items: GroupedAccountItem[] = [];
+  let previousProvider: string | undefined;
+
+  for (const account of sorted) {
+    const provider = providerUtil.normalizeProviderWithCustom(account.provider, providers);
+    if (previousProvider !== provider) {
+      items.push({ type: "header", provider });
+      previousProvider = provider;
+    }
+    items.push({ type: "account", account, provider, active: account.id === activeId });
+  }
+
+  return items;
+}
+
+export function formatAccountItem(item: Extract<GroupedAccountItem, { type: "account" }>): string {
+  const marker = item.active ? "✓" : "·";
+  return `    ${marker} ${item.account.label}`;
+}

package/src/commands/accounts/switch.ts

@@ -0,0 +1,54 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import type { AccountSwitcherContext } from "@/types";
+import { COMMANDS } from "@/constants";
+import { errorUtil, providerUtil } from "@/utils";
+import { AccountCommand } from "./shared";
+
+export const useSwitchAccountCommand = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
+  new SwitchAccountCommand(pi, runtime).register();
+};
+
+class SwitchAccountCommand extends AccountCommand {
+  constructor(pi: ExtensionAPI, runtime: AccountSwitcher) {
+    super(pi, runtime, COMMANDS.accounts.switch);
+  }
+
+  async handler(ctx: AccountSwitcherContext): Promise<void> {
+    try {
+      await this.runtime.load();
+
+      const active = this.runtime.getActiveAccount();
+      if (!active) {
+        ctx.ui.notify("No active account. Use accounts:list to activate one first.", "info");
+        return;
+      }
+
+      const providers = this.runtime.getProviders();
+      const normalizedActive = providerUtil.normalizeProviderWithCustom(
+        active.piAuth?.provider ?? active.provider,
+        providers,
+      );
+      const peers = this.runtime
+        .getAccounts()
+        .filter(
+          (a) =>
+            providerUtil.normalizeProviderWithCustom(a.piAuth?.provider ?? a.provider, providers) ===
+              normalizedActive && a.id !== active.id,
+        );
+
+      if (peers.length === 0) {
+        ctx.ui.notify(`No other accounts for provider "${active.provider}".`, "info");
+        return;
+      }
+
+      const account = await this.pickGroupedAccount(ctx, peers, `Switch account (${active.provider})`);
+      if (!account) return;
+
+      const applied = await this.runtime.activateAccount(account, ctx);
+      ctx.ui.notify(`Switched to ${account.label} (${applied}).`, "info");
+    } catch (e) {
+      ctx.ui.notify(`Failed to switch account: ${errorUtil.format(e)}`, "error");
+    }
+  }
+}

package/src/commands/base.ts

@@ -0,0 +1,81 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import type { AccountConfig, AccountSwitcherContext, ProviderConfig } from "@/types";
+import { providerUtil, uiUtil } from "@/utils";
+
+function deduplicateLabels(labels: string[]): string[] {
+  const seen = new Map<string, number>();
+  return labels.map((label) => {
+    const n = (seen.get(label) ?? 0) + 1;
+    seen.set(label, n);
+    return n > 1 ? `${label} (${n})` : label;
+  });
+}
+
+export interface CommandMeta {
+  readonly name: string;
+  readonly description: string;
+}
+
+export interface Command extends CommandMeta {
+  register(): void;
+  handler(ctx: AccountSwitcherContext): Promise<void>;
+}
+
+export abstract class BaseCommand implements Command {
+  readonly name: string;
+  readonly description: string;
+
+  constructor(
+    protected readonly pi: ExtensionAPI,
+    protected readonly runtime: AccountSwitcher,
+    meta: CommandMeta,
+  ) {
+    this.name = meta.name;
+    this.description = meta.description;
+  }
+
+  register(): void {
+    this.pi.registerCommand(this.name, {
+      description: this.description,
+      handler: (_, ctx) => this.handler(ctx),
+    });
+  }
+
+  protected async pickGrouped<T>(
+    ctx: AccountSwitcherContext,
+    label: string,
+    labels: string[],
+    values: Array<T | null>,
+  ): Promise<T | undefined> {
+    return uiUtil.filteredGroupedSelect(ctx.ui, label, labels, values);
+  }
+
+  protected async pick<T>(
+    ctx: AccountSwitcherContext,
+    label: string,
+    items: T[],
+    format: (item: T) => string,
+  ): Promise<T | undefined> {
+    const raw = items.map(format);
+    const labels = deduplicateLabels(raw);
+    const selected = await uiUtil.filteredSelect(ctx.ui, label, labels);
+    if (!selected) return undefined;
+    return items[labels.indexOf(selected)];
+  }
+
+  protected isActiveAccount(account: AccountConfig): boolean {
+    return this.runtime.getActiveAccount()?.id === account.id;
+  }
+
+  protected isActiveProvider(provider: ProviderConfig): boolean {
+    const active = this.runtime.getActiveAccount();
+    return providerUtil.normalizeProvider(active?.provider ?? "") === provider.id;
+  }
+
+  protected isActiveModel(ctx: AccountSwitcherContext, modelId: string): boolean {
+    return ctx.model?.id === modelId;
+  }
+
+  abstract handler(ctx: AccountSwitcherContext): Promise<void>;
+}

package/src/commands/index.ts

@@ -0,0 +1,16 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import useProviderCommands from "./providers";
+import useAccountCommands from "./accounts";
+import useModelCommands from "./models";
+import useSystemCommands from "./system";
+
+export type { Command, CommandMeta } from "./base";
+export { BaseCommand } from "./base";
+
+export function registerAllCommands(pi: ExtensionAPI, runtime: AccountSwitcher) {
+  useAccountCommands(pi, runtime);
+  useProviderCommands(pi, runtime);
+  useModelCommands(pi, runtime);
+  useSystemCommands(pi, runtime);
+}

package/src/commands/models/add.ts

@@ -0,0 +1,30 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import type { AccountSwitcherContext } from "@/types";
+import { COMMANDS } from "@/constants";
+import { errorUtil } from "@/utils";
+import { ModelCommand, ModelConfigBuilder } from "./shared";
+
+export const useAddModelCommand = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
+  new AddModelCommand(pi, runtime).register();
+};
+
+class AddModelCommand extends ModelCommand {
+  constructor(pi: ExtensionAPI, runtime: AccountSwitcher) {
+    super(pi, runtime, COMMANDS.models.add);
+  }
+
+  async handler(ctx: AccountSwitcherContext): Promise<void> {
+    try {
+      const providerConfig = await this.loadProvider(ctx);
+      if (!providerConfig) return;
+
+      const model = await new ModelConfigBuilder(ctx.ui).collect();
+      const updated = { ...providerConfig, models: [...(providerConfig.models ?? []), model] };
+      await this.runtime.editProvider(providerConfig, updated);
+      ctx.ui.notify(`Added model "${model.id}" to provider "${providerConfig.id}".`, "info");
+    } catch (e) {
+      ctx.ui.notify(`Failed to add model: ${errorUtil.format(e)}`, "error");
+    }
+  }
+}

package/src/commands/models/index.ts

@@ -0,0 +1,13 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import { useListModelsCommand } from "./list";
+import { useAddModelCommand } from "./add";
+import { useRemoveModelCommand } from "./remove";
+
+const useModelCommands = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
+  useListModelsCommand(pi, runtime);
+  useAddModelCommand(pi, runtime);
+  useRemoveModelCommand(pi, runtime);
+};
+
+export default useModelCommands;

package/src/commands/models/list.ts

@@ -0,0 +1,45 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import type { AccountSwitcherContext } from "@/types";
+import { COMMANDS } from "@/constants";
+import { errorUtil } from "@/utils";
+import { ModelCommand } from "./shared";
+
+export const useListModelsCommand = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
+  new ListModelsCommand(pi, runtime).register();
+};
+
+class ListModelsCommand extends ModelCommand {
+  constructor(pi: ExtensionAPI, runtime: AccountSwitcher) {
+    super(pi, runtime, COMMANDS.models.list);
+  }
+
+  async handler(ctx: AccountSwitcherContext): Promise<void> {
+    try {
+      await this.runtime.load();
+
+      const provider = ctx.model?.provider;
+      if (!provider) {
+        ctx.ui.notify("No active model.", "info");
+        return;
+      }
+
+      const models = this.getModels(ctx, provider);
+      if (models.length === 0) {
+        ctx.ui.notify(`No models available for provider "${provider}".`, "info");
+        return;
+      }
+
+      const currentId = ctx.model?.id;
+      const model = await this.pick(ctx, `Models (${provider})`, models, (m) =>
+        m.id === currentId ? `${m.id} ✓` : m.id,
+      );
+      if (!model) return;
+
+      await this.runtime.applyModel(model, ctx);
+      ctx.ui.notify(`Switched to ${model.id}.`, "info");
+    } catch (e) {
+      ctx.ui.notify(`Failed to list models: ${errorUtil.format(e)}`, "error");
+    }
+  }
+}

package/src/commands/models/remove.ts

@@ -0,0 +1,41 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import type { AccountSwitcherContext } from "@/types";
+import { COMMANDS } from "@/constants";
+import { errorUtil } from "@/utils";
+import { ModelCommand } from "./shared";
+
+export const useRemoveModelCommand = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
+  new RemoveModelCommand(pi, runtime).register();
+};
+
+class RemoveModelCommand extends ModelCommand {
+  constructor(pi: ExtensionAPI, runtime: AccountSwitcher) {
+    super(pi, runtime, COMMANDS.models.remove);
+  }
+
+  async handler(ctx: AccountSwitcherContext): Promise<void> {
+    try {
+      const providerConfig = await this.loadProvider(ctx);
+      if (!providerConfig) return;
+
+      const removable = (providerConfig.models ?? []).filter((m) => !this.isActiveModel(ctx, m.id));
+      if (removable.length === 0) {
+        ctx.ui.notify(`Provider "${providerConfig.id}" has no removable model configs.`, "info");
+        return;
+      }
+
+      const model = await this.pick(ctx, "Remove model", removable, (m) => m.name ?? m.id);
+      if (!model) return;
+
+      const confirmed = await ctx.ui.confirm("Remove model?", `Remove "${model.id}" from "${providerConfig.id}"?`);
+      if (!confirmed) return;
+
+      const updated = { ...providerConfig, models: (providerConfig.models ?? []).filter((m) => m.id !== model.id) };
+      await this.runtime.editProvider(providerConfig, updated);
+      ctx.ui.notify(`Removed model "${model.id}" from provider "${providerConfig.id}".`, "info");
+    } catch (e) {
+      ctx.ui.notify(`Failed to remove model: ${errorUtil.format(e)}`, "error");
+    }
+  }
+}