@wuyaos/pi-model-config 0.1.6 → 0.1.8

package/README.md

@@ -178,6 +178,24 @@ Chat 写入 Pi 标准 `models.json`。Classifier 和 image 通过 Pi 的原生 m
 
 插件是与 Pi 同权限运行的扩展，可以读取模型配置和认证。只从可信来源安装；优先使用 `$ENV` 或 Pi auth，避免长期 literal。
 
+## 保存时自动探测参数（auto probe on save）
+
+保存流程进入预览前（`Ctrl+S` 之后、preview 展示之前），插件会对草稿中 metadata 仍标记为 `compat`（即缺少 contextWindow/maxTokens 元数据的）chat 模型逐个串行发送一个最小探测请求：`POST {baseUrl}/chat/completions`，body 为 `{ model, messages: [{ role: "user", content: "用中文写一段约300字的描写" }], max_tokens: 100000 }`，单请求 15 秒超时。每个请求都是真实调用，可能计费；探测期间显示统一盒式进度面板（已完成 X/Y），Esc 可取消剩余请求，已完成的探测结果保留。
+
+推断规则：`finish_reason=length` 且 `usage.completion_tokens_details.reasoning_tokens > 0`（或 `message.reasoning_content` 存在）→ `maxTokens = max(2 × reasoning_tokens, 16384)`，并标 `reasoning=true` + 协议默认 thinkingLevelMap；`finish_reason=length` 无 reasoning → `maxTokens = max(completion_tokens, 16384)`（保守取当前截断点）；`finish_reason=stop` → `maxTokens = 32768`；HTTP 错误、超时、取消或不可信响应 → 该模型静默沿用 128K/16K 兼容默认值。contextWindow 无法由探测可靠测出，保留现有值或 128000 默认，但 metadata 也会标记为 `probed` 表示本轮已探测确认。探测成功回填草稿并标 `maxTokensSource/contextSource/thinkingSource="probed"`；最终落盘仍需 preview 确认，preview 的「模型配置」分类会为新增条目显示「参数已自动探测（实测）」来源标记。
+
+凭据与 URL 安全复用 discovery 的规则：URL 必须通过 `validateHttpUrl`（仅 HTTP(S)、禁止嵌入凭据或密钥查询参数）；`$ENV`/`$$` 字面量按 discovery 同样方式解析；reuse-pi 的 Pi 凭据仅在与模型地址同 origin 时才随探测请求转发。provider 专属代理同样适用于探测请求。探测密钥通过 `Authorization: Bearer` 头发送且不会出现在任何错误提示中。
+
+该功能默认开启；在 `model-config.json` 顶层设置 `"autoProbeOnSave": false` 可整体关闭：
+
+```json
+{
+  "version": 1,
+  "autoProbeOnSave": false,
+  "providers": {}
+}
+```
+
 ## 从 jev-use 迁移到原生 classifier
 
 本插件不会卸载或禁用 `jev-use`。建议手工迁移：

package/model-config.schema.json

@@ -14,6 +14,11 @@
     "version": {
       "const": 1
     },
+    "autoProbeOnSave": {
+      "description": "Pre-save minimal parameter probe for newly checked chat models lacking context/maxTokens metadata. Default true.",
+      "type": "boolean",
+      "default": true
+    },
     "providers": {
       "type": "object",
       "additionalProperties": {
@@ -192,6 +197,14 @@
           },
           "uniqueItems": true
         },
+        "hiddenRemoteIds": {
+          "description": "Remote catalog model IDs hidden by the user across discovery refreshes.",
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "uniqueItems": true
+        },
         "models": {
           "type": "array",
           "items": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wuyaos/pi-model-config",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "type": "module",
   "description": "Pi provider 连接、远程发现与 chat/classifier/image 模型配置 TUI",
   "keywords": [

package/src/auto-probe.ts

@@ -0,0 +1,219 @@
+import type { ExtensionCommandContext, Theme } from "@earendil-works/pi-coding-agent";
+import { Key, matchesKey, type Component, type TUI } from "@earendil-works/pi-tui";
+import { validateHttpUrl } from "./config.ts";
+import { MODEL_CONFIG_OVERLAY_OPTIONS, renderPanelBox } from "./panel.ts";
+import { t, type UiLanguage } from "./i18n.ts";
+import { protocolThinkingMap } from "./thinking-defaults.ts";
+import type { ProviderDraft, ThinkingLevelMap } from "./types.ts";
+
+/** Defaults applied when the minimal probe request fails or cannot be trusted. */
+export const AUTO_PROBE_TIMEOUT_MS = 15_000;
+export const AUTO_PROBE_MAX_TOKENS_REQUEST = 100_000;
+const PROBE_PROMPT = "用中文写一段约300字的描写";
+
+export interface AutoProbeResult {
+  /** Inferred output ceiling. Context window is intentionally not probed. */
+  maxTokens: number;
+  reasoning: boolean;
+  thinkingLevelMap?: ThinkingLevelMap;
+}
+
+export interface ProbeChatParamsOptions {
+  fetch?: typeof fetch;
+  apiKey?: string;
+  baseUrl: string;
+  signal: AbortSignal;
+  timeoutMs?: number;
+}
+
+/**
+ * Pure inference from a minimal chat-completions response. Returns null whenever the
+ * observation is not trustworthy, so callers can fall back to compatibility defaults.
+ */
+export function inferAutoProbeParams(
+  payload: {
+    finishReason?: unknown;
+    reasoningContent?: unknown;
+    reasoningTokens?: unknown;
+    completionTokens?: unknown;
+  },
+  api: string,
+): AutoProbeResult | null {
+  const reasoningTokens = typeof payload.reasoningTokens === "number" && Number.isFinite(payload.reasoningTokens) && payload.reasoningTokens > 0
+    ? Math.floor(payload.reasoningTokens)
+    : 0;
+  const hasReasoningContent = typeof payload.reasoningContent === "string" && payload.reasoningContent.trim().length > 0;
+  const reasoning = hasReasoningContent || reasoningTokens > 0;
+  const finish = payload.finishReason;
+  if (finish === "length") {
+    // Truncated mid-reasoning: the model wanted at least its reasoning budget twice.
+    const maxTokens = reasoningTokens > 0 ? Math.max(2 * reasoningTokens, 16_384) : Math.max(Math.floor(Number(payload.completionTokens)) || 0, 16_384);
+    const protocol = reasoning ? protocolThinkingMap(api) : undefined;
+    return { maxTokens, reasoning, ...(protocol ? { thinkingLevelMap: protocol } : {}) };
+  }
+  if (finish === "stop") return { maxTokens: 32_768, reasoning };
+  // tool_calls / content_filter / unknown shapes are not trustworthy for sizing.
+  return null;
+}
+
+/**
+ * One minimal paid-capable request against an OpenAI-compatible /chat/completions
+ * endpoint. Never throws: every failure path resolves to null so the save flow can
+ * silently keep compatibility defaults. URL handling reuses validateHttpUrl, matching
+ * discovery SSRF rules (HTTP(S) only, no embedded credentials or secret queries).
+ */
+export async function probeChatParams(model: { id: string; api: string }, options: ProbeChatParamsOptions): Promise<AutoProbeResult | null> {
+  try {
+    const base = validateHttpUrl(options.baseUrl, "Base URL").replace(/\/+$/u, "");
+    const url = validateHttpUrl(`${base}/chat/completions`, "Probe URL");
+    const headers: Record<string, string> = { "content-type": "application/json" };
+    if (options.apiKey) headers.authorization = `Bearer ${options.apiKey}`;
+    const combined = AbortSignal.any([options.signal, AbortSignal.timeout(options.timeoutMs ?? AUTO_PROBE_TIMEOUT_MS)]);
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    const response = await fetchImpl(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        model: model.id,
+        messages: [{ role: "user", content: PROBE_PROMPT }],
+        max_tokens: AUTO_PROBE_MAX_TOKENS_REQUEST,
+      }),
+      signal: combined,
+    });
+    if (!response.ok) return null;
+    const text = await response.text();
+    let body: any;
+    try { body = JSON.parse(text); } catch { return null; }
+    const choice = Array.isArray(body?.choices) ? body.choices[0] : undefined;
+    if (!choice || typeof choice !== "object") return null;
+    return inferAutoProbeParams({
+      finishReason: choice.finish_reason,
+      reasoningContent: choice.message?.reasoning_content,
+      reasoningTokens: body?.usage?.completion_tokens_details?.reasoning_tokens,
+      completionTokens: body?.usage?.completion_tokens,
+    }, model.api);
+  } catch {
+    // Abort (user Esc or timeout) and any transport/validation failure fall back to defaults.
+    return null;
+  }
+}
+
+function originOf(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  try { return new URL(validateHttpUrl(value, "Base URL")).origin; } catch { return undefined; }
+}
+
+/**
+ * Resolve the credential used by the probe request, applying the same origin
+ * containment as discovery for reused Pi credentials: an existing key is never
+ * forwarded to a different origin than the one it was issued for.
+ */
+export function resolveProbeApiKey(
+  draft: Pick<ProviderDraft, "authMode" | "apiKeyRaw" | "temporaryKey">,
+  piAuth: { auth?: { apiKey?: string; baseUrl?: string } } | undefined,
+  baseUrl: string,
+): string | undefined {
+  if (draft.authMode === "models-json") {
+    const raw = draft.apiKeyRaw;
+    const envMatch = raw?.match(/^\$(?:\{([A-Za-z_][A-Za-z0-9_]*)\}|([A-Za-z_][A-Za-z0-9_]*))$/u);
+    if (envMatch) return process.env[envMatch[1] ?? envMatch[2]!];
+    if (raw?.startsWith("$$") || raw?.startsWith("$!")) return raw.slice(1);
+    return raw;
+  }
+  if (draft.authMode === "temporary") return draft.temporaryKey;
+  if (draft.authMode === "reuse-pi") {
+    const key = piAuth?.auth?.apiKey;
+    if (!key) return undefined;
+    const authOrigin = originOf(piAuth?.auth?.baseUrl);
+    const modelOrigin = originOf(baseUrl);
+    if (!authOrigin || !modelOrigin || authOrigin !== modelOrigin) return undefined;
+    return key;
+  }
+  return undefined;
+}
+
+/** Chat models whose metadata still marks context/maxTokens as unverified compat defaults. */
+export function probeTargetsFor(
+  models: ReadonlyArray<{ type: string; id: string }>,
+  metadata: ReadonlyArray<{ type: string; id: string; contextSource?: string; maxTokensSource?: string }>,
+): Array<{ type: string; id: string }> {
+  return models.filter((model) => {
+    if (model.type !== "chat") return false;
+    const entry = metadata.find((item) => item.type === model.type && item.id === model.id);
+    return !entry || entry.contextSource === "compat" || entry.maxTokensSource === "compat";
+  });
+}
+
+export interface ProbeQueueEntry<T> {
+  label: string;
+  run: (signal: AbortSignal) => Promise<T | null>;
+}
+
+export interface ProbeQueueOutcome<T> {
+  result: T | null;
+  /** True when this entry was skipped because the user pressed Esc earlier. */
+  cancelled: boolean;
+}
+
+/** Serial runner shared by the TUI panel and tests; one request at a time, abort stops the rest. */
+export async function runProbeQueue<T>(
+  entries: ReadonlyArray<ProbeQueueEntry<T>>,
+  signal: AbortSignal,
+  onProgress?: (done: number, total: number, current: string) => void,
+): Promise<Array<ProbeQueueOutcome<T>>> {
+  const outcomes: Array<ProbeQueueOutcome<T>> = [];
+  for (const entry of entries) {
+    if (signal.aborted) { outcomes.push({ result: null, cancelled: true }); continue; }
+    onProgress?.(outcomes.length, entries.length, entry.label);
+    const result = await entry.run(signal);
+    outcomes.push({ result, cancelled: false });
+    onProgress?.(outcomes.length, entries.length, entry.label);
+  }
+  return outcomes;
+}
+
+class AutoProbePanel<T> implements Component {
+  private controller = new AbortController();
+  private done = 0;
+  private current = "";
+  constructor(
+    private tui: TUI,
+    private theme: Theme,
+    private language: UiLanguage,
+    private entries: ReadonlyArray<ProbeQueueEntry<T>>,
+    done: (outcomes: Array<ProbeQueueOutcome<T>>) => void,
+  ) {
+    void runProbeQueue(this.entries, this.controller.signal, (completed, _total, label) => {
+      this.done = completed;
+      this.current = label;
+      this.tui.requestRender();
+    }).then((outcomes) => {
+      this.done = outcomes.length;
+      this.current = "";
+      this.tui.requestRender();
+      done(outcomes);
+    });
+  }
+  handleInput(data: string): void { if (matchesKey(data, Key.escape)) this.controller.abort(new DOMException("Cancelled", "AbortError")); }
+  render(width: number): string[] {
+    const lines = [t(this.language, "autoProbeProgress", { done: this.done, total: this.entries.length, model: this.current })];
+    return renderPanelBox(lines, width, t(this.language, "autoProbePanelTitle"), this.theme);
+  }
+  invalidate(): void {}
+  dispose(): void { this.controller.abort(); }
+}
+
+/**
+ * Unified boxed progress panel for the pre-save auto probe. Shows X/Y completed and
+ * lets Esc cancel the remaining (not in-flight) requests; completed results are kept.
+ */
+export async function runAutoProbeFlow<T>(
+  ctx: ExtensionCommandContext,
+  language: UiLanguage,
+  entries: ReadonlyArray<ProbeQueueEntry<T>>,
+): Promise<Array<ProbeQueueOutcome<T>>> {
+  return ctx.ui.custom<Array<ProbeQueueOutcome<T>>>(
+    (tui, theme, _keys, done) => new AutoProbePanel(tui, theme, language, entries, done),
+    MODEL_CONFIG_OVERLAY_OPTIONS,
+  );
+}

package/src/command.ts

@@ -12,12 +12,15 @@ import {
   writeConfigTransaction,
 } from "./config.ts";
 import { buildDiscoveryCandidates, discoverModelsFromCandidates } from "./discovery.ts";
+import { createProviderFetch } from "./transport.ts";
+import { probeChatParams, probeTargetsFor, resolveProbeApiKey, runAutoProbeFlow } from "./auto-probe.ts";
 import { formatError, mcError, t, type UiLanguage } from "./i18n.ts";
 import {
   showConnectionPanel,
   showPreviewPanel,
   showProviderPanel,
   showConfirmationPanel,
+  showRestoreHiddenPanel,
   type MenuPanelState,
   type OverviewPanelState,
   type PanelItem,
@@ -36,7 +39,7 @@ import type {
   ProviderConnectionConfig,
   ProviderDraft,
 } from "./types.ts";
-import { identityOf } from "./types.ts";
+import { hiddenRemoteKey, identityOf, isHiddenRemote, normalizeHiddenRemoteKeys } from "./types.ts";
 import { loadUiLanguage, saveUiLanguage } from "./ui-config.ts";
 import { secretInput, withCancellableLoader } from "./ui.ts";
 import { showModelTestFlow } from "./model-test.ts";
@@ -157,6 +160,7 @@ function draftFrom(providerId: string, provider: ModelsJsonProvider | undefined,
     classifierApi: config?.classifierApi ?? "typesafe-system-one",
     imageApi: config?.imageApi ?? "openrouter-images",
     defaultType: config?.defaultType ?? "chat",
+    hiddenRemoteIds: normalizeHiddenRemoteKeys(config?.hiddenRemoteIds ?? []),
   };
 }
 
@@ -248,9 +252,9 @@ function connectionPanelFields(language: UiLanguage, draft: ProviderDraft): Pane
   ];
 }
 
-async function editConnectionPanel(ctx: ExtensionCommandContext, language: UiLanguage, draft: ProviderDraft, state: MenuPanelState, canTakeover: boolean): Promise<"models" | "takeover" | "testModels" | "preview" | "back"> {
+async function editConnectionPanel(ctx: ExtensionCommandContext, language: UiLanguage, draft: ProviderDraft, state: MenuPanelState, canTakeover: boolean, hiddenRemoteCount: number): Promise<"models" | "takeover" | "restoreHidden" | "testModels" | "preview" | "back"> {
   while (true) {
-    const result = await showConnectionPanel(ctx, language, draft.id, connectionPanelFields(language, draft), state, canTakeover);
+    const result = await showConnectionPanel(ctx, language, draft.id, connectionPanelFields(language, draft), state, canTakeover, hiddenRemoteCount);
     if (result.action !== "field") return result.action;
     try {
       switch (result.fieldId) {
@@ -424,8 +428,10 @@ export function applyChanges(
   if (draft.authMode === "models-json") provider.apiKey = draft.apiKeyRaw; else delete provider.apiKey;
   models.providers[providerId] = provider;
 
+  const normalizedHiddenRemoteIds = normalizeHiddenRemoteKeys(draft.hiddenRemoteIds ?? []);
+  const { hiddenRemoteIds: _oldHiddenRemoteIds, ...oldConfigWithoutHiddenRemoteIds } = oldConfig ?? {};
   config.providers[providerId] = {
-    ...(oldConfig ?? {}),
+    ...oldConfigWithoutHiddenRemoteIds,
     name: draft.name,
     owned: draft.owned,
     enabled: draft.enabled,
@@ -436,6 +442,7 @@ export function applyChanges(
     imageApi: draft.imageApi,
     defaultType: draft.defaultType,
     managedChatIds: selectedChat.map((model) => model.id),
+    ...(normalizedHiddenRemoteIds.length ? { hiddenRemoteIds: normalizedHiddenRemoteIds } : {}),
     models: selected.filter((model): model is Extract<ManagedModel, { type: "classifier" | "image" }> => model.type !== "chat"),
     modelMetadata: modelMetadata.map((entry) => structuredClone(entry)),
   };
@@ -452,6 +459,7 @@ function buildPreviewDetails(
   oldConfig: ProviderConnectionConfig | undefined,
   oldProvider: ModelsJsonProvider | undefined,
   draft: ProviderDraft,
+  metadata: ReadonlyArray<ModelMetadataEntry> = [],
 ): { providerDetails: string[]; modelDetails: string[] } {
   const oldMap = new Map(before.map((model) => [identityOf(model, providerId), model]));
   const newMap = new Map(after.map((model) => [identityOf(model, providerId), model]));
@@ -492,6 +500,13 @@ function buildPreviewDetails(
     const model = newMap.get(key) ?? oldMap.get(key)!;
     return `${modelTypeLabel(language, model.type)}/${model.id}`;
   };
+  // Newly added rows whose metadata was just probed get an explicit source marker.
+  const describeAdded = (key: ReturnType<typeof identityOf>) => {
+    const model = newMap.get(key)!;
+    const entry = metadata.find((item) => item.type === model.type && item.id === model.id);
+    const probed = entry?.contextSource === "probed" || entry?.maxTokensSource === "probed";
+    return `${describe(key)}${probed ? ` · ${t(language, "previewProbedDefaults")}` : ""}`;
+  };
   const settingsChanged = oldConnection !== nextConnection;
   const keyWillUpdate = draft.authMode === "models-json" && oldProvider?.apiKey !== draft.apiKeyRaw;
   return {
@@ -501,7 +516,7 @@ function buildPreviewDetails(
       ...(keyWillUpdate ? [t(language, "previewKeyUpdated")] : []),
     ],
     modelDetails: [
-      ...(added.length ? [t(language, "previewModelsAdded", { items: added.map(describe).join(", ") })] : []),
+      ...(added.length ? [t(language, "previewModelsAdded", { items: added.map(describeAdded).join(", ") })] : []),
       ...(deleted.length ? [t(language, "previewModelsRemoved", { items: deleted.map(describe).join(", ") })] : []),
       ...(modified.length ? [t(language, "previewModelsModified", { items: modified.map(describe).join(", ") })] : []),
       t(language, "previewModelsUnchanged", { count: unchanged }),
@@ -514,6 +529,7 @@ export interface ProviderChoice {
   id: string;
   label: string;
   priority: number;
+  enabled: boolean;
 }
 
 export function buildConfiguredProviderChoices(
@@ -524,20 +540,21 @@ export function buildConfiguredProviderChoices(
 ): ProviderChoice[] {
   const ids = new Set([...Object.keys(models.providers), ...Object.keys(config.providers)]);
   const choices: ProviderChoice[] = [];
-  for (const id of ids) {
+  for (const id of [...ids].sort((a, b) => a.localeCompare(b))) {
     const owned = config.providers[id]?.owned === true;
     const builtin = builtinProviderIds.has(id);
     const name = config.providers[id]?.name ?? models.providers[id]?.name;
     const displayBase = name && name !== id ? `${name} (${id})` : id;
     const display = config.providers[id]?.enabled === false ? `${displayBase} · ${t(language, "providerDisabled")}` : displayBase;
     const status = t(language, builtin ? "providerTagBuiltin" : "providerTagCustom");
+    const enabled = config.providers[id]?.enabled !== false;
     choices.push(owned
-      ? { id, label: t(language, "providerLabelCustom", { display, status }), priority: 0 }
+      ? { id, label: t(language, "providerLabelCustom", { display, status }), priority: 0, enabled }
       : builtin
-        ? { id, label: t(language, "providerLabelBuiltin", { display, status }), priority: 1 }
-        : { id, label: t(language, "providerLabelCustom", { display, status }), priority: 2 });
+        ? { id, label: t(language, "providerLabelBuiltin", { display, status }), priority: 1, enabled }
+        : { id, label: t(language, "providerLabelCustom", { display, status }), priority: 2, enabled });
   }
-  return choices.sort((a, b) => a.priority - b.priority || a.id.localeCompare(b.id));
+  return choices.sort((a, b) => Number(b.enabled) - Number(a.enabled) || a.priority - b.priority || a.id.localeCompare(b.id));
 }
 
 function buildProviderPanelItems(
@@ -591,7 +608,7 @@ function buildProviderPanelItems(
 export function buildBuiltinProviderChoices(language: UiLanguage, builtinProviderIds: Iterable<string>): ProviderChoice[] {
   return [...new Set(builtinProviderIds)]
     .sort((a, b) => a.localeCompare(b))
-    .map((id) => ({ id, label: t(language, "providerLabelBuiltin", { display: id, status: t(language, "providerTagBuiltin") }), priority: 0 }));
+    .map((id) => ({ id, label: t(language, "providerLabelBuiltin", { display: id, status: t(language, "providerTagBuiltin") }), priority: 0, enabled: true }));
 }
 
 async function chooseBuiltinProvider(ctx: ExtensionCommandContext, language: UiLanguage): Promise<{ id: string; isNew: false } | undefined> {
@@ -657,6 +674,7 @@ function draftPanelItem(language: UiLanguage, draft: ProviderDraft, selected: Ma
     ],
     modelDetails: [
       t(language, "panelSummaryModels", { chat, classifier, image }),
+      ...(draft.hiddenRemoteIds?.length ? [t(language, "panelHiddenRemoteCount", { count: draft.hiddenRemoteIds.length })] : []),
       t(language, "detailFetchHint"),
       ...(adoptableCount ? [t(language, "panelTakeoverCount", { count: adoptableCount })] : []),
     ],
@@ -840,6 +858,7 @@ export function registerModelConfigCommand(pi: ExtensionAPI, startupIssues: Star
 
           let selectedDraft = structuredClone(baselineSelected);
           let cachedRemote: CandidateModel[] = [];
+          let fetchInFlight = false;
           let page: "connection" | "model" | "preview" = "connection";
           let previewOrigin: "connection" | "model" = "model";
           const connectionState: MenuPanelState = { focus: "list", actionIndex: 0, detailScroll: 0 };
@@ -873,6 +892,48 @@ export function registerModelConfigCommand(pi: ExtensionAPI, startupIssues: Star
               });
               if (empty !== "confirm") return false;
             }
+            if (files.config.autoProbeOnSave !== false && draft.enabled) {
+              const wanted = new Set(probeTargetsFor(selectedDraft, selectedMetadata).map((model) => `${model.type}\u0000${model.id}`));
+              const targets = selectedDraft
+                .map((model, index) => ({ model, index, metadataIndex: selectedMetadata.findIndex((entry) => entry.type === model.type && entry.id === model.id) }))
+                .filter(({ model }) => wanted.has(`${model.type}\u0000${model.id}`));
+              if (targets.length) {
+                try {
+                  const piAuth = draft.authMode === "reuse-pi" ? await ctx.modelRegistry.getProviderAuth(target.id) : undefined;
+                  const fetchImpl = draft.proxyUrl ? createProviderFetch(draft.proxyUrl) : globalThis.fetch;
+                  const entries = targets.map(({ model }) => ({
+                    label: model.id,
+                    run: (signal: AbortSignal) => {
+                      const baseUrl = model.type === "chat" ? model.baseUrl ?? draft.baseUrl : draft.baseUrl;
+                      if (!baseUrl) return Promise.resolve(null);
+                      return probeChatParams(model, { fetch: fetchImpl, apiKey: resolveProbeApiKey(draft, piAuth, baseUrl), baseUrl, signal });
+                    },
+                  }));
+                  const outcomes = await runAutoProbeFlow(ctx, language, entries);
+                  for (let index = 0; index < targets.length; index++) {
+                    const { model, metadataIndex } = targets[index]!;
+                    const outcome = outcomes[index]!;
+                    if (model.type !== "chat" || outcome.cancelled || !outcome.result) continue;
+                    const result = outcome.result;
+                    model.maxTokens = result.maxTokens;
+                    model.reasoning = result.reasoning;
+                    if (result.reasoning && result.thinkingLevelMap) model.thinkingLevelMap = { ...result.thinkingLevelMap };
+                    else delete model.thinkingLevelMap;
+                    const metadata = {
+                      ...(metadataIndex >= 0 ? selectedMetadata[metadataIndex] : { type: model.type, id: model.id }),
+                      contextSource: "probed" as const,
+                      maxTokensSource: "probed" as const,
+                      thinkingSource: "probed" as const,
+                      verifiedAt: new Date().toISOString(),
+                    };
+                    if (metadataIndex >= 0) selectedMetadata[metadataIndex] = metadata; else selectedMetadata.push(metadata);
+                  }
+                  if (outcomes.some((outcome) => outcome.cancelled)) ctx.ui.notify(t(language, "autoProbeCancelled"), "info");
+                } catch {
+                  // Probe failures are silent: unprobed models keep compatibility defaults.
+                }
+              }
+            }
             return true;
           };
           const adoptExisting = async (): Promise<boolean> => {
@@ -898,10 +959,15 @@ export function registerModelConfigCommand(pi: ExtensionAPI, startupIssues: Star
 
           providerSession: while (true) {
             if (page === "connection") {
-              const connection = await editConnectionPanel(ctx, language, draft, connectionState, adoptableIds().length > 0);
+              const connection = await editConnectionPanel(ctx, language, draft, connectionState, adoptableIds().length > 0, draft.hiddenRemoteIds?.length ?? 0);
               activeSecrets.push(draft.apiKeyRaw, draft.temporaryKey);
               if (connection === "models") { page = "model"; continue; }
               if (connection === "takeover") { if (await adoptExisting()) page = "model"; continue; }
+              if (connection === "restoreHidden") {
+                const restored = await showRestoreHiddenPanel(ctx, language, draft.hiddenRemoteIds ?? []);
+                if (restored.action === "apply") draft.hiddenRemoteIds = (draft.hiddenRemoteIds ?? []).filter((key) => !restored.restored.includes(key));
+                continue;
+              }
               if (connection === "testModels") {
                 if (!draft.enabled) { ctx.ui.notify(t(language, "testProviderDisabled"), "warning"); continue; }
                 if (draft.authMode === "temporary" || isDirty()) { ctx.ui.notify(t(language, "testDraftDirty"), "warning"); continue; }
@@ -934,7 +1000,8 @@ export function registerModelConfigCommand(pi: ExtensionAPI, startupIssues: Star
               const installedRaw = installedModels(ctx, target.id);
               const installed = installedRaw.map(candidateFromInstalled);
               const external = externalModels.map((model) => candidateFromExternal(model, externalMetadata.get(model.id)));
-              const candidates = mergeCandidates(target.id, [...external, ...installed], managedBefore.map((model) => candidateFromManaged(model, persistedMetadata.get(`${model.type}\0${model.id}`))), cachedRemote);
+              const visibleRemote = cachedRemote.filter((model) => !isHiddenRemote(model, draft.hiddenRemoteIds ?? []));
+              const candidates = mergeCandidates(target.id, [...external, ...installed], managedBefore.map((model) => candidateFromManaged(model, persistedMetadata.get(`${model.type}\0${model.id}`))), visibleRemote);
               const selection = await selectModels(ctx, language, target.id, draft, candidates, selectedDraft, modelState, selectedMetadata);
               selectedDraft = selection.selected;
               selectedMetadata = selection.metadata.map((entry) => ({ ...(selectedMetadata.find((old) => old.type === entry.type && old.id === entry.id) ?? {}), ...entry }));
@@ -987,6 +1054,9 @@ export function registerModelConfigCommand(pi: ExtensionAPI, startupIssues: Star
                 continue;
               }
               if (selection.action === "fetch") {
+                if (fetchInFlight) continue;
+                fetchInFlight = true;
+                try {
                 const fallbackBases = [
                   ...(oldProvider?.models ?? []).map((model) => typeof model.baseUrl === "string" ? model.baseUrl : undefined),
                   ...installedRaw.map((model) => model.baseUrl),
@@ -1029,12 +1099,13 @@ export function registerModelConfigCommand(pi: ExtensionAPI, startupIssues: Star
                 draft.discoveryUrl = result.value!.url;
                 cachedRemote = [...result.value!.models];
                 continue;
+                } finally { fetchInFlight = false; }
               }
               if (await preparePreview()) { previewOrigin = "model"; page = "preview"; }
               continue;
             }
 
-            const details = buildPreviewDetails(language, target.id, managedBefore, selectedDraft, oldConfig, oldProvider, draft);
+            const details = buildPreviewDetails(language, target.id, managedBefore, selectedDraft, oldConfig, oldProvider, draft, selectedMetadata);
             const preview = await showPreviewPanel(ctx, language, target.id, details.providerDetails, details.modelDetails, previewState);
             if (preview.action === "back") { page = previewOrigin; continue; }
             if (preview.action === "discard") {
@@ -1049,10 +1120,7 @@ export function registerModelConfigCommand(pi: ExtensionAPI, startupIssues: Star
               if (discard === "discard") continue mainLoop;
               continue;
             }
-            const compatItems = selectedMetadata.filter((entry) => entry.contextSource === "compat" || entry.maxTokensSource === "compat").map((entry) => entry.type + '/' + entry.id);
-            const risk = compatItems.length ? [t(language, "compatSaveRisk", { items: compatItems.join(", ") })] : [];
-            const confirmed = await confirmAction(ctx, language, t(language, "finalSaveTitle"), [t(language, "finalSaveBody"), ...risk], [...details.providerDetails, ...details.modelDetails], t(language, "confirmSave"));
-            if (!confirmed) continue;
+            // Preview is the sole save confirmation: Ctrl+S there commits the reviewed draft.
             try {
               const next = applyChanges(files, target.id, draft, selectedDraft, new Set(externalModels.map((model) => model.id)), selectedMetadata);
               const transaction = writeConfigTransaction(files.modelsSnapshot, files.configSnapshot, next.models, next.config);

package/src/config.ts

@@ -60,6 +60,9 @@ export function parseModelConfig(source: ConfigSnapshot): ModelConfigFile {
   if (!isRecord(parsed) || parsed.version !== 1 || !isRecord(parsed.providers)) {
     throw mcError("MCFG_E_CONFIG_SHAPE", { file: "model-config.json" });
   }
+  if (parsed.autoProbeOnSave !== undefined && typeof parsed.autoProbeOnSave !== "boolean") {
+    throw mcError("MCFG_E_CONFIG_SHAPE", { file: "model-config.json" });
+  }
   for (const [id, provider] of Object.entries(parsed.providers)) {
     if (!isRecord(provider)) throw mcError("MCFG_E_PROVIDER_SHAPE", { file: "model-config.json", provider: id });
     if (!new Set(["models-json", "reuse-pi", "anonymous"]).has(String(provider.authMode))) {
@@ -72,6 +75,7 @@ export function parseModelConfig(source: ConfigSnapshot): ModelConfigFile {
     if (provider.imageApi !== undefined && !IMAGE_API_NAMES.includes(String(provider.imageApi) as typeof IMAGE_API_NAMES[number])) {
       throw mcError("MCFG_E_UNSUPPORTED_API", { identity: `${id}/image`, api: String(provider.imageApi) });
     }
+    if (provider.hiddenRemoteIds !== undefined && (!Array.isArray(provider.hiddenRemoteIds) || provider.hiddenRemoteIds.some((modelId) => typeof modelId !== "string"))) throw mcError("MCFG_E_PROVIDER_SHAPE", { file: "model-config.json", provider: id });
     if (provider.models !== undefined && !Array.isArray(provider.models)) throw mcError("MCFG_E_MODELS_ARRAY", { file: "model-config.json", provider: id });
     if (Array.isArray(provider.models) && provider.models.some((model) => !isRecord(model))) throw mcError("MCFG_E_MODELS_ARRAY", { file: "model-config.json", provider: id });
     for (const model of Array.isArray(provider.models) ? provider.models : []) {

package/src/i18n.ts

@@ -38,6 +38,13 @@ const ZH = {
   detailConnectionTitle: "连接摘要",
   detailModelsTitle: "模型概况",
   detailFetchHint: "进入“配置模型”后按 Ctrl+R 获取远程模型列表",
+  detailRestoreHidden: "[Ctrl+H] 恢复隐藏模型（{count}）",
+  panelHiddenRemoteCount: "已隐藏远程模型：{count}",
+  restoreHiddenTitle: "恢复隐藏远程模型",
+  restoreHiddenItemDetail: "勾选后恢复到后续远程获取结果；保存前仅修改内存草稿。",
+  restoreHiddenAll: "[Ctrl+A] 全部恢复",
+  restoreHiddenApply: "[Ctrl+S] 应用恢复",
+  restoreHiddenBack: "[Esc] 返回",
   detailEditConnection: "[Ctrl+E] 编辑连接",
   detailConfigureModels: "[Ctrl+M] 配置模型",
   detailTakeover: "[Ctrl+T] 全选并纳入管理",
@@ -99,6 +106,7 @@ const ZH = {
   modelProbeContext: "[Ctrl+K] 探测上下文容量",
   modelProbeThinking: "[Ctrl+L] 探测思考档位",
   modelFetch: "[Ctrl+R] 获取远程模型列表",
+  modelHideRemote: "[Ctrl+Del] 隐藏远程模型",
   modelPreview: "[Ctrl+S] 预览更改",
   modelBack: "[Esc] 返回服务商",
   addProviderTitle: "添加服务商",
@@ -297,6 +305,10 @@ const ZH = {
   previewSettingsUnchanged: "服务商设置无更改",
   previewKeyUpdated: "API 密钥：将更新，内容已隐藏",
   previewModelsAdded: "添加模型：{items}",
+  autoProbePanelTitle: "保存前参数探测",
+  autoProbeProgress: "探测 {done}/{total}：{model}；Esc 取消剩余（已完成项保留）",
+  autoProbeCancelled: "已取消自动探测；剩余模型沿用兼容默认值（128K/16K）",
+  previewProbedDefaults: "参数已自动探测（实测）",
   previewModelsRemoved: "移除模型：{items}",
   previewModelsModified: "修改模型：{items}",
   previewModelsUnchanged: "未变化模型：{count}",
@@ -312,6 +324,7 @@ const ZH = {
   selectorReadonlyRuntime: "此模型来自 Pi 内置目录或其他运行时扩展，不能在这里移除",
   selectorTypeConflict: "不能切换为{type}：{identity} 已存在",
   selectorReadonlyTag: "只读",
+  selectorRemoteHidden: "已隐藏远程模型 {id}；保存后后续获取也会隐藏",
   selectorTypeChat: "聊天",
   selectorTypeClassifier: "判定",
   selectorTypeImage: "图像生成",
@@ -372,6 +385,13 @@ const EN = {
   detailConnectionTitle: "Connection Summary",
   detailModelsTitle: "Model Overview",
   detailFetchHint: "Open Configure models, then press Ctrl+R to fetch the remote model list",
+  detailRestoreHidden: "[Ctrl+H] Restore hidden models ({count})",
+  panelHiddenRemoteCount: "Hidden remote models: {count}",
+  restoreHiddenTitle: "Restore hidden remote models",
+  restoreHiddenItemDetail: "Checked entries return to future remote fetch results; this only changes the in-memory draft until save.",
+  restoreHiddenAll: "[Ctrl+A] Restore all",
+  restoreHiddenApply: "[Ctrl+S] Apply restore",
+  restoreHiddenBack: "[Esc] Back",
   detailEditConnection: "[Ctrl+E] Edit connection",
   detailConfigureModels: "[Ctrl+M] Configure models",
   detailTakeover: "[Ctrl+T] Select all and manage",
@@ -433,6 +453,7 @@ const EN = {
   modelProbeContext: "[Ctrl+K] Probe context capacity",
   modelProbeThinking: "[Ctrl+L] Probe thinking levels",
   modelFetch: "[Ctrl+R] Fetch remote model list",
+  modelHideRemote: "[Ctrl+Del] Hide remote model",
   modelPreview: "[Ctrl+S] Preview changes",
   modelBack: "[Esc] Back to provider",
   addProviderTitle: "Add Provider",
@@ -631,6 +652,10 @@ const EN = {
   previewSettingsUnchanged: "Provider settings unchanged",
   previewKeyUpdated: "API key: will be updated; content is hidden",
   previewModelsAdded: "Add models: {items}",
+  autoProbePanelTitle: "Pre-save parameter probe",
+  autoProbeProgress: "Probing {done}/{total}: {model}; Esc cancels the rest (completed results are kept)",
+  autoProbeCancelled: "Auto-probe cancelled; remaining models keep compatibility defaults (128K/16K)",
+  previewProbedDefaults: "parameters auto-probed",
   previewModelsRemoved: "Remove models: {items}",
   previewModelsModified: "Modify models: {items}",
   previewModelsUnchanged: "Unchanged models: {count}",
@@ -646,6 +671,7 @@ const EN = {
   selectorReadonlyRuntime: "This model comes from Pi's built-in catalog or another runtime extension and cannot be removed here",
   selectorTypeConflict: "Cannot change to {type}: {identity} already exists",
   selectorReadonlyTag: "read-only",
+  selectorRemoteHidden: "Remote model {id} is hidden and will remain hidden after saving and future fetches",
   selectorTypeChat: "Chat",
   selectorTypeClassifier: "Classification",
   selectorTypeImage: "Image generation",

package/src/image-apis/common.ts

@@ -130,13 +130,13 @@ function privateHostname(hostname: string): boolean {
     const low = Number.parseInt(mappedHex[2]!, 16);
     normalized = `${high >>> 8}.${high & 0xff}.${low >>> 8}.${low & 0xff}`;
   }
-  if (normalized === "localhost" || normalized.endsWith(".localhost") || normalized === "::1" || normalized === "0:0:0:0:0:0:0:1") return true;
+  if (normalized === "localhost" || normalized.endsWith(".localhost") || normalized === "::" || normalized === "0:0:0:0:0:0:0:0" || normalized === "::1" || normalized === "0:0:0:0:0:0:0:1") return true;
   const ipv4 = normalized.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/u)?.slice(1).map(Number);
   if (ipv4 && ipv4.every((part) => part >= 0 && part <= 255)) {
     const [a, b] = ipv4;
     return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168;
   }
-  return normalized.startsWith("fc") || normalized.startsWith("fd") || normalized.startsWith("fe80:");
+  return normalized.startsWith("fc") || normalized.startsWith("fd") || /^(?:fe8|fe9|fea|feb)[0-9a-f]:/u.test(normalized);
 }
 
 export function validatePublicImageUrl(value: string): URL {

package/src/panel.ts

@@ -43,7 +43,7 @@ export type ProviderPanelResult =
 
 export type ConnectionPanelResult =
   | { action: "field"; fieldId: string }
-  | { action: "models" | "takeover" | "testModels" | "preview" | "back" };
+  | { action: "models" | "takeover" | "restoreHidden" | "testModels" | "preview" | "back" };
 
 export type PreviewPanelResult = { action: "save" | "back" | "discard" };
 
@@ -434,11 +434,13 @@ export async function showConnectionPanel(
   fields: PanelItem[],
   state: MenuPanelState = { focus: "list", actionIndex: 0, detailScroll: 0 },
   canTakeover = false,
+  hiddenRemoteCount = 0,
 ): Promise<ConnectionPanelResult> {
   const actions: FooterAction[] = [
     { id: "edit", label: t(language, "connectionModify"), key: Key.enter },
     { id: "models", label: t(language, "detailConfigureModels"), key: Key.ctrl("m") },
     ...(canTakeover ? [{ id: "takeover", label: t(language, "detailTakeover"), key: Key.ctrl("t") }] : []),
+    ...(hiddenRemoteCount > 0 ? [{ id: "restoreHidden", label: t(language, "detailRestoreHidden", { count: hiddenRemoteCount }), key: Key.ctrl("h") }] : []),
     { id: "testModels", label: t(language, "detailTestModels"), key: Key.ctrl("p") },
     { id: "preview", label: t(language, "connectionPreview"), key: Key.ctrl("s") },
     { id: "back", label: t(language, "connectionBack"), key: Key.escape },
@@ -448,10 +450,33 @@ export async function showConnectionPanel(
   if (result.kind === "back" || result.id === "back") return { action: "back" };
   if (result.kind === "item" && result.id) return { action: "field", fieldId: result.id };
   if (result.id === "edit" && state.selectedId) return { action: "field", fieldId: state.selectedId };
-  if (result.id === "models" || result.id === "takeover" || result.id === "testModels" || result.id === "preview") return { action: result.id };
+  if (result.id === "models" || result.id === "takeover" || result.id === "restoreHidden" || result.id === "testModels" || result.id === "preview") return { action: result.id };
   return { action: "back" };
 }
 
+export async function showRestoreHiddenPanel(
+  ctx: ExtensionCommandContext,
+  language: UiLanguage,
+  hiddenKeys: string[],
+  state: MenuPanelState = { focus: "list", actionIndex: 0, detailScroll: 0 },
+): Promise<{ action: "apply" | "back"; restored: string[] }> {
+  const selected = new Set<string>();
+  const actions: FooterAction[] = [
+    { id: "all", label: t(language, "restoreHiddenAll"), key: Key.ctrl("a") },
+    { id: "apply", label: t(language, "restoreHiddenApply"), key: Key.ctrl("s") },
+    { id: "back", label: t(language, "restoreHiddenBack"), key: Key.escape },
+  ];
+  while (true) {
+    const items = hiddenKeys.map((key) => ({ id: key, label: `${selected.has(key) ? "[✓]" : "[ ]"} ${key.replace("\u0000", "/")}`, details: [t(language, "restoreHiddenItemDetail")] }));
+    const result = await ctx.ui.custom<{ kind: "item" | "action" | "language" | "back"; id?: string }>((tui, theme, _keys, done) =>
+      new MenuDetailPanel(tui, theme, language, t(language, "restoreHiddenTitle"), items, actions, state, true, done), MODEL_CONFIG_OVERLAY_OPTIONS);
+    if (result.kind === "back" || result.id === "back") return { action: "back", restored: [] };
+    if (result.kind === "item" && result.id) { if (selected.has(result.id)) selected.delete(result.id); else selected.add(result.id); continue; }
+    if (result.id === "all") { for (const hiddenKey of hiddenKeys) selected.add(hiddenKey); continue; }
+    if (result.id === "apply") return { action: "apply", restored: [...selected] };
+  }
+}
+
 export async function showPreviewPanel(
   ctx: ExtensionCommandContext,
   language: UiLanguage,

package/src/selector.ts

@@ -15,7 +15,7 @@ import { t, type UiLanguage } from "./i18n.ts";
 import { COMPAT_CONTEXT_WINDOW, COMPAT_MAX_TOKENS } from "./discovery.ts";
 import { MODEL_CONFIG_OVERLAY_OPTIONS, overlayViewportRows, renderActionFooter, renderPanelBox, type FooterAction } from "./panel.ts";
 import type { CandidateModel, ManagedModel, ManagedModelType, ModelMetadataEntry, ProviderDraft, SelectionResult, ThinkingLevelMap, ThinkingMetadataSource } from "./types.ts";
-import { identityOf } from "./types.ts";
+import { hiddenRemoteKey, identityOf } from "./types.ts";
 import { protocolThinkingMap } from "./thinking-defaults.ts";
 import { describeThinking } from "./model-editor.ts";
 
@@ -218,6 +218,19 @@ class ModelSelector implements Component, Focusable {
     this.tui.requestRender();
   }
 
+  private hideCurrentRemote(): void {
+    const row = this.current();
+    if (!row || row.source !== "remote") return;
+    const hidden = new Set(this.draft.hiddenRemoteIds ?? []);
+    hidden.add(hiddenRemoteKey(row));
+    this.draft.hiddenRemoteIds = [...hidden].sort((a, b) => a.localeCompare(b));
+    this.selected.delete(this.key(row));
+    const index = this.rows.indexOf(row);
+    if (index >= 0) this.rows.splice(index, 1);
+    this.status = t(this.language, "selectorRemoteHidden", { id: row.id });
+    this.refresh();
+  }
+
   private cycleType(): void {
     const row = this.filtered[this.index];
     if (!row?.mutableType) return;
@@ -277,6 +290,7 @@ class ModelSelector implements Component, Focusable {
       { id: "probe", label: t(this.language, "modelProbeContext"), key: Key.ctrl("k") },
       { id: "probeThinking", label: t(this.language, "modelProbeThinking"), key: Key.ctrl("l") },
       { id: "fetch", label: t(this.language, "modelFetch"), key: Key.ctrl("r") },
+      { id: "hideRemote", label: t(this.language, "modelHideRemote"), key: Key.ctrl("delete"), enabled: this.current()?.source === "remote" },
       { id: "preview", label: t(this.language, "modelPreview"), key: Key.ctrl("s") },
       { id: "back", label: t(this.language, "modelBack"), key: Key.escape },
     ];
@@ -301,12 +315,14 @@ class ModelSelector implements Component, Focusable {
     if (action.id === "selectFiltered") { for (const row of this.filtered) if (!row.readOnly) this.selected.add(this.key(row)); this.request(); return; }
     if (action.id === "deselectFiltered") { for (const row of this.filtered) if (!row.readOnly) this.selected.delete(this.key(row)); this.request(); return; }
     if (action.id === "cycleType") { this.cycleType(); return; }
+    if (action.id === "hideRemote") { this.hideCurrentRemote(); return; }
     this.finish(action.id as SelectionResult["action"]);
   }
 
   handleInput(data: string): void {
     if (data === "/") { this.state.focus = "search"; this.request(); return; }
     if (matchesKey(data, Key.ctrl("r"))) { this.finish("fetch"); return; }
+    if (matchesKey(data, Key.ctrl("delete"))) { this.hideCurrentRemote(); return; }
     if (matchesKey(data, Key.ctrl("e"))) { this.finish("edit"); return; }
     if (matchesKey(data, Key.ctrl("k"))) { this.finish("probe"); return; }
     if (matchesKey(data, Key.ctrl("l"))) { this.finish("probeThinking"); return; }

package/src/types.ts

@@ -71,6 +71,8 @@ export interface ProviderConnectionConfig {
   defaultContextWindow?: number;
   defaultMaxTokens?: number;
   managedChatIds?: string[];
+  /** Remote catalog keys (`type\0id`) hidden by the user; retained across discovery refreshes. */
+  hiddenRemoteIds?: string[];
   models?: Array<ManagedClassifierModel | ManagedImageModel>;
   modelMetadata?: ModelMetadataEntry[];
 }
@@ -78,6 +80,8 @@ export interface ProviderConnectionConfig {
 export interface ModelConfigFile {
   $schema?: string;
   version: 1;
+  /** Pre-save minimal parameter probe for newly checked chat models lacking context/max metadata; default true. */
+  autoProbeOnSave?: boolean;
   providers: Record<string, ProviderConnectionConfig>;
   [key: string]: unknown;
 }
@@ -115,6 +119,7 @@ export interface ProviderDraft {
   classifierApi: string;
   imageApi: ImageApiName;
   defaultType: ManagedModelType;
+  hiddenRemoteIds?: string[];
 }
 
 export type CandidateModel = ManagedModel & {
@@ -142,6 +147,20 @@ export interface ConfigSnapshot {
   text?: string;
 }
 
+/** Persistent remote-hide identity. Legacy id-only entries are interpreted as chat-only on read. */
+export function hiddenRemoteKey(model: Pick<ManagedModel, "id" | "type">): string { return `${model.type}\u0000${model.id}`; }
+
+export function isHiddenRemote(model: Pick<ManagedModel, "id" | "type">, hiddenKeys: readonly string[]): boolean {
+  const key = hiddenRemoteKey(model);
+  // Compatibility: prior releases stored bare IDs; treating those as chat-only prevents
+  // a legacy hidden chat model from also hiding classifier/image models with the same ID.
+  return hiddenKeys.includes(key) || model.type === "chat" && hiddenKeys.includes(model.id);
+}
+
+export function normalizeHiddenRemoteKeys(hiddenKeys: readonly string[]): string[] {
+  return [...new Set(hiddenKeys.map((key) => key.includes("\u0000") ? key : hiddenRemoteKey({ type: "chat", id: key })))].sort((a, b) => a.localeCompare(b));
+}
+
 export function identityOf(model: Pick<ManagedModel, "id" | "type"> & { provider?: string }, provider?: string): ModelIdentity {
   const p = provider ?? model.provider ?? "";
   return `${p}\u0000${model.type}\u0000${model.id}`;