@wuyaos/pi-model-config 0.1.7 → 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": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wuyaos/pi-model-config",
-  "version": "0.1.7",
+  "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,6 +12,8 @@ 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,
@@ -457,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]));
@@ -497,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 {
@@ -506,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 }),
@@ -882,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> => {
@@ -1053,7 +1105,7 @@ export function registerModelConfigCommand(pi: ExtensionAPI, startupIssues: Star
               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") {

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))) {

package/src/i18n.ts

@@ -305,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}",
@@ -648,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}",

package/src/types.ts

@@ -80,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;
 }