pi-better-model-select 0.1.4 → 0.3.0

package/extensions/lib/flows.ts

@@ -1,34 +1,12 @@
-// Add / update / delete flows against the effective model configuration.
-//
-// Each mutation follows the saved write mode, then re-reads the target file
-// before saving so another pi session's edit is not silently clobbered.
+// Model definitions and effort preferences are drafts until the form's Save action.
+import { editForm, tableSelect, confirmAction } from "./tui.ts";
+import { editModelEfforts, modelEffortDraft, saveModelEfforts, type EffortDraft } from "./effort-editor.ts";
+import { DEFAULT_CONTEXT_WINDOW, DEFAULT_MAX_TOKENS, fetchModelMeta, listEndpointModels, parsePositiveInt, providerEndpoint, resolveKey, type ModelMeta } from "./meta.ts";
+import { configContainsModel, loadConfig, loadConfigFile, loadSettings, saveConfig, tombstoneModel, upsertModel, writeTarget, type ModelEntry, type ModelsConfig } from "./store.ts";
 
-import {
-  DEFAULT_CONTEXT_WINDOW,
-  DEFAULT_MAX_TOKENS,
-  fetchModelMeta,
-  listEndpointModels,
-  parsePositiveInt,
-  providerEndpoint,
-  resolveKey,
-  type ModelMeta,
-} from "./meta.ts";
-import {
-  configContainsModel,
-  loadConfig,
-  loadConfigFile,
-  loadSettings,
-  saveConfig,
-  tombstoneModel,
-  upsertModel,
-  writeTarget,
-  type ConfigTarget,
-  type ModelEntry,
-  type ModelsConfig,
-} from "./store.ts";
-
-// Minimal shape of the pi extension command context we rely on.
 export interface FlowCtx {
+  cwd?: string;
+  isProjectTrusted?: () => boolean;
   ui: {
     notify: (message: string, level: string) => void;
     select: (message: string, options: string[]) => Promise<string | undefined>;
@@ -36,462 +14,144 @@ export interface FlowCtx {
     confirm: (title: string, message: string) => Promise<boolean>;
   };
 }
-
-const INPUT_OPTIONS: string[][] = [["text"], ["text", "image"]];
-
-function selectedWriteTarget(): ConfigTarget {
-  return writeTarget(loadSettings());
-}
-
-function providerOverlay(config: ModelsConfig, providerName: string): Record<string, unknown> {
-  const provider = config.providers?.[providerName] ?? {};
-  const { models: _models, ...settings } = provider;
-  return settings;
-}
-
-function completeModel(config: ModelsConfig, providerName: string, modelId: string): ModelEntry | undefined {
-  const model = config.providers?.[providerName]?.models?.find((entry) => entry.id === modelId);
-  return model ? structuredClone(model) : undefined;
-}
-
-function ensureProviderSettings(
-  targetConfig: ModelsConfig,
-  effectiveConfig: ModelsConfig,
-  providerName: string,
-): void {
-  targetConfig.providers = targetConfig.providers ?? {};
-  targetConfig.providers[providerName] = {
-    ...providerOverlay(effectiveConfig, providerName),
-    ...(targetConfig.providers[providerName] ?? {}),
-  };
+function ensureProviderSettings(target: ModelsConfig, effective: ModelsConfig, provider: string): void {
+  const { models: _models, ...settings } = effective.providers?.[provider] ?? {};
+  target.providers ??= {};
+  target.providers[provider] = { ...settings, ...target.providers[provider] };
 }
-
-/** Present a yes/no as a select so ESC can cancel — confirm() cannot. */
-async function selectYesNo(
-  ctx: FlowCtx,
-  message: string,
-  defaultYes: boolean,
-): Promise<boolean | undefined> {
-  const first = defaultYes ? "yes" : "no";
-  const pick = await ctx.ui.select(message, [first, defaultYes ? "no" : "yes"]);
-  return pick === undefined ? undefined : pick === "yes";
+async function pickModel(ctx: FlowCtx, config: ModelsConfig, title: string) {
+  const models = Object.entries(config.providers ?? {}).flatMap(([provider, entry]) => (entry.models ?? []).map(model => ({ provider, model })));
+  if (!models.length) { ctx.ui.notify("No models configured.", "info"); return; }
+  const value = await tableSelect(ctx, { title, search: true, columns: [{ key: "model", label: "MODEL" }, { key: "provider", label: "PROVIDER" }], rows: models.map(({ provider, model }, index) => ({ value: String(index), label: model.name ?? model.id, cells: { model: model.id, provider } })) });
+  return value === undefined ? undefined : models[Number(value)];
 }
 
-async function selectInput(
-  ctx: FlowCtx,
-  message: string,
-  current: string[],
-): Promise<string[] | undefined> {
-  const labels = INPUT_OPTIONS.map((o) => o.join("+"));
-  const idx = labels.indexOf(current.join("+"));
-  const def = labels[Math.max(idx, 0)]!;
-  const pick = await ctx.ui.select(message, [def, ...labels.filter((l) => l !== def)]);
-  if (pick === undefined) return undefined;
-  return INPUT_OPTIONS[labels.indexOf(pick)] ?? ["text"];
+/** Shared add/update form. Field dialogs only mutate this draft, never files.
+ * Text and numeric edits use Pi input dialogs until a safe inline editor exists.
+ */
+async function modelForm(ctx: FlowCtx, provider: string, initial: ModelEntry, meta: ModelMeta, adding: boolean): Promise<boolean> {
+  const draft = structuredClone(initial);
+  const changes = new Set<string>();
+  const key = `${provider}/${draft.id}`;
+  let efforts = modelEffortDraft(ctx, key, Boolean(draft.reasoning), meta.effortLevels);
+  let effortsChanged = adding;
+  const field = (name: string, label: string, value: string, edit: () => Promise<string | undefined>, description?: string) => ({ key: name, label, value, edit, description });
+  const numberField = (name: "contextWindow" | "maxTokens", label: string, fallback: number) => field(name, label, String(draft[name] ?? fallback), async () => {
+    const suggested = meta[name] ?? draft[name] ?? fallback;
+    const raw = await ctx.ui.input(label, String(suggested));
+    if (raw === undefined) return;
+    draft[name] = parsePositiveInt(raw, suggested);
+    changes.add(name);
+    return String(draft[name]);
+  }, meta[name] === undefined ? undefined : `Provider: ${meta[name]}`);
+  return editForm(ctx, {
+    title: `${adding ? "Add" : "Update"} ${key}`,
+    hint: `Save writes ${writeTarget(loadSettings())}. Text and numbers open input dialogs.`,
+    fields: [
+      field("identity", "Model", key, async () => undefined, "Identity is fixed; cancel to choose another model."),
+      field("name", "Display name", draft.name ?? draft.id, async () => {
+        const raw = await ctx.ui.input("Display name", draft.name ?? draft.id);
+        if (raw === undefined) return;
+        draft.name = raw || draft.id; changes.add("name"); return draft.name;
+      }),
+      numberField("contextWindow", "Context window", DEFAULT_CONTEXT_WINDOW),
+      numberField("maxTokens", "Max output tokens", DEFAULT_MAX_TOKENS),
+      field("reasoning", "Reasoning", draft.reasoning ? "yes" : "no", async () => {
+        const value = await tableSelect(ctx, { title: "Reasoning model?", initialValue: draft.reasoning ? "yes" : "no", rows: ["no", "yes"].map(value => ({ value, label: value })) });
+        if (value === undefined) return;
+        const reasoning = value === "yes";
+        // Do not change the visible field if its dependent effort draft is cancelled.
+        const initialEfforts = reasoning === Boolean(draft.reasoning) ? efforts : modelEffortDraft(ctx, key, reasoning, meta.effortLevels);
+        const next = await editModelEfforts(ctx, key, reasoning, meta.effortLevels, initialEfforts);
+        if (!next) return;
+        draft.reasoning = reasoning; efforts = next; effortsChanged = true; changes.add("reasoning"); return value;
+      }),
+      field("input", "Input", (draft.input ?? ["text"]).join("+"), async () => {
+        const value = await tableSelect(ctx, { title: "Input modalities", rows: ["text", "text+image"].map(value => ({ value, label: value })) });
+        if (value === undefined) return;
+        draft.input = value.split("+"); changes.add("input"); return value;
+      }),
+      field("efforts", "Available / preferred efforts", effortLabel(efforts), async () => {
+        const next = await editModelEfforts(ctx, key, Boolean(draft.reasoning), meta.effortLevels, efforts);
+        if (!next) return;
+        efforts = next; effortsChanged = true; return effortLabel(efforts);
+      }),
+    ],
+    onSave: async () => {
+      const target = writeTarget(loadSettings());
+      const effective = loadConfig(ctx);
+      const config = loadConfigFile(ctx, target, target === "models.bms.json");
+      if (!effective || !config) return false;
+      if (!effective.providers?.[provider]) { ctx.ui.notify(`Provider "${provider}" no longer exists.`, "error"); return false; }
+      const current = effective.providers[provider]!.models?.find(model => model.id === draft.id);
+      if (adding ? !!current : !current) { ctx.ui.notify(adding ? "Model is already configured." : "Model no longer exists.", "warning"); return false; }
+      if (effortsChanged && !saveModelEfforts(ctx, key, efforts)) return false;
+      const entry = adding ? draft : structuredClone(current!);
+      if (!adding) for (const name of changes) (entry as any)[name] = (draft as any)[name];
+      ensureProviderSettings(config, effective, provider);
+      upsertModel(config, provider, entry);
+      saveConfig(config, target);
+      ctx.ui.notify(`${adding ? "Added" : "Updated"} ${key} in ${target}.`, "info");
+      return true;
+    },
+  });
 }
+function effortLabel(draft: EffortDraft): string { return `${draft.capability.levels.join(", ")}; preferred ${draft.preferred ?? "automatic"}`; }
 
-// ----- add -----------------------------------------------------------------
-
-export async function addFlow(ctx: FlowCtx): Promise<void> {
+export async function addFlow(ctx: FlowCtx, onAdded?: (provider: string, modelId: string) => Promise<void>): Promise<void> {
   const config = loadConfig(ctx);
   if (!config) return;
   const providers = config.providers ?? {};
-
-  const names = Object.keys(providers).filter((n) => typeof providers[n]?.baseUrl === "string");
-  if (names.length === 0) {
-    ctx.ui.notify("No providers with a baseUrl in the effective model config", "warning");
-    return;
-  }
-
-  // Running breadcrumb of everything chosen so far, shown atop each prompt.
-  const crumbs: string[] = [];
-  const header = () =>
-    crumbs.length ? `Selected so far:\n${crumbs.map((c) => `  • ${c}`).join("\n")}\n\n` : "";
-
-  const providerName = await ctx.ui.select(`${header()}Select provider:`, names);
-  if (providerName === undefined) return;
-  const provider = providers[providerName]!;
-  crumbs.push(`Provider: ${providerName}`);
-
-  const base = String(provider.baseUrl).replace(/\/+$/, "");
-  const key = resolveKey(provider.apiKey);
-
+  const names = Object.keys(providers).filter(name => typeof providers[name]?.baseUrl === "string");
+  if (!names.length) { ctx.ui.notify("No providers with a baseUrl in the effective model config", "warning"); return; }
+  const provider = await tableSelect(ctx, { title: "Select provider", search: true, rows: names.map(value => ({ value, label: value })) });
+  if (provider === undefined) return;
+  const entry = providers[provider]!;
+  const base = String(entry.baseUrl).replace(/\/+$/, "");
+  const key = resolveKey(entry.apiKey);
   let ids: string[];
-  try {
-    ids = await listEndpointModels(base, key);
-  } catch (e) {
-    ctx.ui.notify(`Failed to list models: ${e}`, "error");
-    return;
-  }
-
-  const existing = new Set((provider.models ?? []).map((m) => m.id));
-  const candidates = ids.filter((id) => !existing.has(id)).sort();
-  if (candidates.length === 0) {
-    ctx.ui.notify("All endpoint models are already configured", "info");
-    return;
-  }
-
-  const modelId = await ctx.ui.select(
-    `${header()}Add which model to "${providerName}"?`,
-    candidates,
-  );
-  if (modelId === undefined) return;
-  crumbs.push(`Model: ${modelId}`);
-
-  const meta = await fetchModelMeta(base, key, modelId);
-
-  const prefilled: string[] = [];
-  if (meta.contextWindow !== undefined) prefilled.push(`ctx=${meta.contextWindow}`);
-  if (meta.maxTokens !== undefined) prefilled.push(`max=${meta.maxTokens}`);
-  if (meta.reasoning !== undefined) prefilled.push(`reasoning=${meta.reasoning}`);
-  if (prefilled.length > 0) {
-    ctx.ui.notify(`Auto-filled from provider: ${prefilled.join(", ")}`, "info");
-  }
-
-  const nameRaw = await ctx.ui.input(`${header()}Display name:`, modelId);
-  if (nameRaw === undefined) return;
-  const name = nameRaw || modelId;
-  crumbs.push(`Name: ${name}`);
-
-  const cwDefault = meta.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
-  const cwRaw = await ctx.ui.input(`${header()}Context window:`, String(cwDefault));
-  if (cwRaw === undefined) return;
-  const contextWindow = parsePositiveInt(cwRaw, cwDefault);
-  crumbs.push(`Context window: ${contextWindow}`);
-
-  const mtDefault = meta.maxTokens ?? DEFAULT_MAX_TOKENS;
-  const mtRaw = await ctx.ui.input(`${header()}Max output tokens:`, String(mtDefault));
-  if (mtRaw === undefined) return;
-  const maxTokens = parsePositiveInt(mtRaw, mtDefault);
-  crumbs.push(`Max output tokens: ${maxTokens}`);
-
-  const reasoning = await selectYesNo(
-    ctx,
-    `${header()}Reasoning model?`,
-    Boolean(meta.reasoning),
-  );
-  if (reasoning === undefined) return;
-  crumbs.push(`Reasoning: ${reasoning ? "yes" : "no"}`);
-
-  const input = await selectInput(ctx, `${header()}Input modalities:`, meta.input ?? ["text"]);
-  if (input === undefined) return;
-  crumbs.push(`Input: ${input.join("+")}`);
-
-  const targetFile = selectedWriteTarget();
-  const ok = await ctx.ui.confirm(
-    `${header()}Add this model to "${providerName}"?`,
-    `Write the entry to ${targetFile}?`,
-  );
-  if (!ok) {
-    ctx.ui.notify("Cancelled. Nothing written.", "info");
-    return;
-  }
-
-  const freshEffective = loadConfig(ctx);
-  const freshTarget = loadConfigFile(ctx, targetFile, targetFile === "models.bms.json");
-  if (!freshEffective || !freshTarget) return;
-  if (!freshEffective.providers?.[providerName]) {
-    ctx.ui.notify(`Provider "${providerName}" no longer exists.`, "error");
-    return;
-  }
-  if (configContainsModel(freshEffective, providerName, modelId)) {
-    ctx.ui.notify(`Model "${modelId}" is already configured in ${providerName}.`, "warning");
-    return;
-  }
-  ensureProviderSettings(freshTarget, freshEffective, providerName);
-  upsertModel(freshTarget, providerName, {
-    id: modelId,
-    name,
-    reasoning,
-    input,
-    contextWindow,
-    maxTokens,
-  });
-  saveConfig(freshTarget, targetFile);
-  ctx.ui.notify(`Added "${modelId}" to ${providerName} in ${targetFile}.`, "info");
-}
-
-// ----- update --------------------------------------------------------------
-
-interface Field {
-  key: string;
-  label: string;
-  current: string;
-  suggest?: string;
-  edit: (header: () => string) => Promise<unknown | undefined>;
+  try { ids = await listEndpointModels(base, key); }
+  catch (error) { ctx.ui.notify(`Failed to list models: ${error}`, "error"); return; }
+  const existing = new Set((entry.models ?? []).map(model => model.id));
+  const candidates = ids.filter(id => !existing.has(id)).sort();
+  if (!candidates.length) { ctx.ui.notify("All endpoint models are already configured", "info"); return; }
+  const id = await tableSelect(ctx, { title: `Add model to ${provider}`, search: true, rows: candidates.map(value => ({ value, label: value })) });
+  if (id === undefined) return;
+  const meta = await fetchModelMeta(base, key, id);
+  const saved = await modelForm(ctx, provider, { id, name: id, contextWindow: meta.contextWindow ?? DEFAULT_CONTEXT_WINDOW, maxTokens: meta.maxTokens ?? DEFAULT_MAX_TOKENS, reasoning: Boolean(meta.reasoning), input: meta.input ?? ["text"] }, meta, true);
+  if (saved && onAdded && await confirmAction(ctx, { title: "Set as Pi default?", lines: [`Configure ${provider}/${id} for new sessions?`], confirmLabel: "Configure default" })) await onAdded(provider, id);
 }
-
-export async function updateFlow(
-  ctx: FlowCtx,
-  preselect?: { provider: string; modelId: string },
-): Promise<void> {
+export async function updateFlow(ctx: FlowCtx, preselect?: { provider: string; modelId: string }): Promise<void> {
   const config = loadConfig(ctx);
   if (!config) return;
-  const providers = config.providers ?? {};
-
-  let providerName: string;
-  let existing: ModelEntry;
-
-  if (preselect && providers[preselect.provider]?.models?.some((m) => m.id === preselect.modelId)) {
-    providerName = preselect.provider;
-    existing = providers[preselect.provider]!.models!.find((m) => m.id === preselect.modelId)!;
-  } else {
-    const map = new Map<string, { provider: string; model: ModelEntry }>();
-    for (const p of Object.keys(providers)) {
-      for (const m of providers[p]!.models ?? []) {
-        const label = `${m.name ?? m.id}   [${p}]  (ctx: ${m.contextWindow ?? "?"}, max: ${m.maxTokens ?? "?"}, reasoning: ${m.reasoning ? "yes" : "no"})`;
-        map.set(label, { provider: p, model: m });
-      }
-    }
-    if (map.size === 0) {
-      ctx.ui.notify("No models configured to update.", "info");
-      return;
-    }
-    const label = await ctx.ui.select("Update which model?", [...map.keys()]);
-    if (label === undefined) return;
-    const hit = map.get(label)!;
-    providerName = hit.provider;
-    existing = hit.model;
-  }
-
-  // Try to refresh metadata from the provider.
-  const ep = providerEndpoint(config, providerName);
-  let meta: ModelMeta = {};
-  if (ep) {
-    meta = await fetchModelMeta(ep.base, ep.key, existing.id);
-    const diffs: string[] = [];
-    if (meta.contextWindow !== undefined && meta.contextWindow !== existing.contextWindow)
-      diffs.push(`ctx: ${existing.contextWindow ?? "?"} → ${meta.contextWindow}`);
-    if (meta.maxTokens !== undefined && meta.maxTokens !== existing.maxTokens)
-      diffs.push(`max: ${existing.maxTokens ?? "?"} → ${meta.maxTokens}`);
-    if (meta.reasoning !== undefined && meta.reasoning !== (existing.reasoning ?? false))
-      diffs.push(`reasoning: ${existing.reasoning ?? false} → ${meta.reasoning}`);
-    if (meta.input !== undefined && meta.input.join("+") !== (existing.input ?? ["text"]).join("+"))
-      diffs.push(`input: ${(existing.input ?? ["text"]).join("+")} → ${meta.input.join("+")}`);
-    ctx.ui.notify(
-      diffs.length > 0
-        ? `Provider suggests updates: ${diffs.join(", ")}`
-        : "Provider info matches current config — no changes suggested.",
-      "info",
-    );
-  }
-
-  const fields: Field[] = [
-    {
-      key: "name",
-      label: "Display name",
-      current: existing.name ?? existing.id,
-      edit: async (header) => {
-        const raw = await ctx.ui.input(`${header()}Display name:`, existing.name ?? existing.id);
-        return raw === undefined ? undefined : raw || existing.id;
-      },
-    },
-    {
-      key: "contextWindow",
-      label: "Context window",
-      current: String(existing.contextWindow ?? DEFAULT_CONTEXT_WINDOW),
-      suggest: meta.contextWindow !== undefined ? String(meta.contextWindow) : undefined,
-      edit: async (header) => {
-        const cur = existing.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
-        const def = meta.contextWindow ?? cur;
-        const hint =
-          meta.contextWindow !== undefined && meta.contextWindow !== cur
-            ? ` (provider: ${meta.contextWindow}, current: ${cur})`
-            : "";
-        const raw = await ctx.ui.input(`${header()}Context window${hint}:`, String(def));
-        return raw === undefined ? undefined : parsePositiveInt(raw, def);
-      },
-    },
-    {
-      key: "maxTokens",
-      label: "Max output tokens",
-      current: String(existing.maxTokens ?? DEFAULT_MAX_TOKENS),
-      suggest: meta.maxTokens !== undefined ? String(meta.maxTokens) : undefined,
-      edit: async (header) => {
-        const cur = existing.maxTokens ?? DEFAULT_MAX_TOKENS;
-        const def = meta.maxTokens ?? cur;
-        const hint =
-          meta.maxTokens !== undefined && meta.maxTokens !== cur
-            ? ` (provider: ${meta.maxTokens}, current: ${cur})`
-            : "";
-        const raw = await ctx.ui.input(`${header()}Max output tokens${hint}:`, String(def));
-        return raw === undefined ? undefined : parsePositiveInt(raw, def);
-      },
-    },
-    {
-      key: "reasoning",
-      label: "Reasoning model",
-      current: existing.reasoning ? "yes" : "no",
-      suggest: meta.reasoning !== undefined ? (meta.reasoning ? "yes" : "no") : undefined,
-      edit: async (header) =>
-        selectYesNo(
-          ctx,
-          `${header()}Reasoning model?`,
-          meta.reasoning ?? existing.reasoning ?? false,
-        ),
-    },
-    {
-      key: "input",
-      label: "Input modalities",
-      current: (existing.input ?? ["text"]).join("+"),
-      suggest: meta.input !== undefined ? meta.input.join("+") : undefined,
-      edit: async (header) =>
-        selectInput(
-          ctx,
-          `${header()}Input modalities:`,
-          meta.input ?? existing.input ?? ["text"],
-        ),
-    },
-  ];
-
-  const changes = new Map<string, unknown>();
-  for (;;) {
-    const options = fields.map(
-      (f) =>
-        `${changes.has(f.key) ? "•" : "·"} ${f.label}: ${f.current}${
-          f.suggest !== undefined && f.suggest !== f.current ? ` → provider: ${f.suggest}` : ""
-        }${changes.has(f.key) ? `  [changed: ${String(changes.get(f.key))}]` : ""}`,
-    );
-    const pick = await ctx.ui.select(
-      `Update which attribute of ${existing.id} [${providerName}]?\n(• = will be written, ESC to finish)`,
-      [...options, "Done — write changes"],
-    );
-    if (pick === undefined || pick.startsWith("Done")) break;
-    const idx = options.indexOf(pick);
-    const field = fields[idx];
-    if (!field) continue;
-    const value = await field.edit(() => `Model: ${existing.id} [${providerName}]\n`);
-    if (value === undefined) continue; // ESC in the field editor — back to list
-    changes.set(field.key, value);
-  }
-
-  if (changes.size === 0) {
-    ctx.ui.notify("No changes made.", "info");
-    return;
-  }
-
-  const targetFile = selectedWriteTarget();
-  const ok = await ctx.ui.confirm(
-    `Update ${existing.id}?`,
-    `Write ${[...changes.keys()].join(", ")} to "${providerName}" in ${targetFile}?`,
-  );
-  if (!ok) {
-    ctx.ui.notify("Cancelled. Nothing updated.", "info");
-    return;
-  }
-
-  const freshEffective = loadConfig(ctx);
-  const freshTarget = loadConfigFile(ctx, targetFile, targetFile === "models.bms.json");
-  if (!freshEffective || !freshTarget) return;
-  const modelEntry = completeModel(freshEffective, providerName, existing.id);
-  if (!modelEntry) {
-    ctx.ui.notify(`Model "${existing.id}" no longer exists in ${providerName}.`, "error");
-    return;
-  }
-  Object.assign(modelEntry, Object.fromEntries(changes));
-  ensureProviderSettings(freshTarget, freshEffective, providerName);
-  upsertModel(freshTarget, providerName, modelEntry);
-  saveConfig(freshTarget, targetFile);
-  ctx.ui.notify(
-    `Updated "${existing.id}" in ${providerName} via ${targetFile}: ${[...changes.entries()]
-      .map(([k, v]) => `${k}=${Array.isArray(v) ? v.join("+") : String(v)}`)
-      .join(", ")}.`,
-    "info",
-  );
+  const found = preselect && config.providers?.[preselect.provider]?.models?.find(model => model.id === preselect.modelId);
+  const hit = found ? { provider: preselect!.provider, model: found } : await pickModel(ctx, config, "Update model");
+  if (!hit) return;
+  const endpoint = providerEndpoint(config, hit.provider);
+  const meta = endpoint ? await fetchModelMeta(endpoint.base, endpoint.key, hit.model.id) : {};
+  await modelForm(ctx, hit.provider, hit.model, meta, false);
 }
-
-// ----- delete --------------------------------------------------------------
-
-export async function deleteFlow(
-  ctx: FlowCtx,
-  preselect?: { provider: string; modelId: string },
-): Promise<void> {
+export async function deleteFlow(ctx: FlowCtx, preselect?: { provider: string; modelId: string }): Promise<void> {
   const config = loadConfig(ctx);
   if (!config) return;
-  const providers = config.providers ?? {};
-
-  let provider: string;
-  let id: string;
-
-  if (preselect && providers[preselect.provider]?.models?.some((m) => m.id === preselect.modelId)) {
-    provider = preselect.provider;
-    id = preselect.modelId;
-  } else {
-    const map = new Map<string, { provider: string; id: string }>();
-    for (const p of Object.keys(providers)) {
-      for (const m of providers[p]!.models ?? []) {
-        map.set(`${m.id}   [${p}]`, { provider: p, id: m.id });
-      }
-    }
-    if (map.size === 0) {
-      ctx.ui.notify("No models configured to delete.", "info");
-      return;
-    }
-    const label = await ctx.ui.select("Delete which model?", [...map.keys()]);
-    if (label === undefined) return;
-    ({ provider, id } = map.get(label)!);
-  }
-
-  const settings = loadSettings();
-  const targetFile = writeTarget(settings);
+  const found = preselect && config.providers?.[preselect.provider]?.models?.find(model => model.id === preselect.modelId);
+  const hit = found ? { provider: preselect!.provider, model: found } : await pickModel(ctx, config, "Delete model");
+  if (!hit) return;
+  const { provider, model: { id } } = hit;
+  const target = writeTarget(loadSettings());
   const base = loadConfigFile(ctx, "models.json");
   if (!base) return;
-
-  if (settings.writeMode === "overlay") {
-    const overlay = loadConfigFile(ctx, "models.bms.json", true);
-    if (!overlay) return;
-    const inherited = configContainsModel(base, provider, id);
-    const local = configContainsModel(overlay, provider, id);
-    if (!inherited && !local) {
-      ctx.ui.notify(`Model "${id}" is no longer present in either config file.`, "warning");
-      return;
-    }
-
-    const ok = await ctx.ui.confirm(
-      `${inherited && !local ? "Hide inherited model" : "Delete"} ${id}?`,
-      inherited && !local
-        ? "Keep models.json unchanged and add a BMS tombstone to models.bms.json?"
-        : `Remove it from "${provider}" in models.bms.json?`,
-    );
-    if (!ok) {
-      ctx.ui.notify("Cancelled. Nothing deleted.", "info");
-      return;
-    }
-
-    if (inherited) tombstoneModel(overlay, provider, id);
-    else {
-      const target = overlay.providers?.[provider];
-      if (target?.models) target.models = target.models.filter((model) => model.id !== id);
-    }
-    saveConfig(overlay, "models.bms.json");
-    ctx.ui.notify(
-      inherited
-        ? `Hidden inherited model "${id}" via models.bms.json.`
-        : `Deleted "${id}" from ${provider} in models.bms.json.`,
-      "info",
-    );
-    return;
-  }
-
-  if (!configContainsModel(base, provider, id)) {
-    ctx.ui.notify(`Model "${id}" is no longer present in models.json.`, "warning");
-    return;
-  }
-  const ok = await ctx.ui.confirm(
-    `Delete ${id}?`,
-    `Remove it from "${provider}" in ${targetFile}?`,
-  );
-  if (!ok) {
-    ctx.ui.notify("Cancelled. Nothing deleted.", "info");
-    return;
-  }
-
-  const fresh = loadConfigFile(ctx, targetFile, targetFile === "models.bms.json");
+  const inherited = target === "models.bms.json" && configContainsModel(base, provider, id);
+  if (!(await confirmAction(ctx, { title: `${inherited ? "Hide" : "Delete"} ${provider}/${id}?`, lines: [inherited ? "Keep models.json unchanged; save a tombstone." : "Remove this model entry.", `Scope: ${target}`], confirmLabel: inherited ? "Hide model" : "Delete model" }))) return;
+  // Re-read after confirmation so another session's changes survive.
+  const fresh = loadConfigFile(ctx, target, target === "models.bms.json");
   if (!fresh) return;
-  const target = fresh.providers?.[provider];
-  if (target?.models) {
-    target.models = target.models.filter((m) => m.id !== id);
-    saveConfig(fresh, targetFile);
-    ctx.ui.notify(`Deleted "${id}" from ${provider} in ${targetFile}.`, "info");
-  }
+  if (inherited) tombstoneModel(fresh, provider, id);
+  else {
+    const entry = fresh.providers?.[provider];
+    if (!entry?.models?.some(model => model.id === id)) { ctx.ui.notify("Model no longer exists in the selected scope.", "warning"); return; }
+    entry.models = entry.models.filter(model => model.id !== id);
+  }
+  saveConfig(fresh, target);
+  ctx.ui.notify(`${inherited ? "Hidden" : "Deleted"} ${provider}/${id} via ${target}.`, "info");
 }