abelworkflow 1.0.0-rc.1 → 1.0.0

package/lib/providers/pi.mjs

@@ -1,4 +1,4 @@
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { join } from "node:path";
 import * as p from "@clack/prompts";
 import { piInsecureTlsHeader } from "../../extensions/pi-gpt-responses-compat/tls-fetch.mjs";
@@ -11,18 +11,33 @@ import {
 } from "../config/store.mjs";
 import { defaultPaths, maskSecret, pathToLabel } from "../paths.mjs";
 
-const piProviderId = "gpt";
-const piDefaultApi = "openai-completions";
-const piDefaultBaseUrl = "https://api.openai.com/v1";
-const piDefaultModel = "gpt-5.5";
 const minimumPiVersion = [0, 80, 0];
+const piRpcRequestId = "abelworkflow-provider";
+const piRpcArgs = [
+  "--mode", "rpc",
+  "--no-session",
+  "--offline",
+  "--no-context-files",
+  "--no-skills",
+  "--no-prompt-templates",
+  "--no-themes"
+];
 
-async function updatePiAuthFile(path, apiKey) {
+function requirePiProviderId(value) {
+  const providerId = typeof value === "string" ? value.trim() : "";
+  if (!providerId) {
+    throw new Error("未检测到 Pi 当前有效 Provider；请先在 Pi 中配置可用模型。");
+  }
+  return providerId;
+}
+
+async function updatePiAuthFile(path, providerId, apiKey) {
+  const targetProviderId = requirePiProviderId(providerId);
   return updateLockedJson(path, (auth) => {
     if (!auth || typeof auth !== "object" || Array.isArray(auth)) {
       throw new TypeError("Pi auth.json must contain a JSON object");
     }
-    return buildPiAuthConfig(auth, apiKey);
+    return buildPiAuthConfig(auth, targetProviderId, apiKey);
   }, {
     sensitive: true,
     retries: {
@@ -43,12 +58,12 @@ function parsePiVersion(value) {
 function assertSupportedPiVersion(value) {
   const version = parsePiVersion(value);
   if (!version) {
-    throw new Error("无法检测 Pi 版本；配置自定义 Provider 需要 Pi 0.80.0 或更高版本。");
+    throw new Error("无法检测 Pi 版本（可能尚未安装）；请先安装 Pi 0.80.0 或更高版本。");
   }
   for (let index = 0; index < minimumPiVersion.length; index += 1) {
     if (version[index] > minimumPiVersion[index]) return version;
     if (version[index] < minimumPiVersion[index]) {
-      throw new Error(`当前 Pi ${version.join(".")} 不支持 auth-only 自定义 Provider；请升级到 Pi 0.80.0 或更高版本。`);
+      throw new Error(`当前 Pi ${version.join(".")} 不支持 auth-only 自定义 Provider；请先升级到 Pi 0.80.0 或更高版本。`);
     }
   }
   return version;
@@ -63,6 +78,105 @@ function detectPiVersion() {
   return result.status === 0 ? `${result.stdout || ""} ${result.stderr || ""}`.trim() : undefined;
 }
 
+function parsePiRpcEffectiveModel(value) {
+  for (const line of String(value || "").split(/\r?\n/u)) {
+    let payload;
+    try {
+      payload = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const model = payload?.type === "response"
+      && payload.command === "get_state"
+      && payload.success === true
+      ? payload.data?.model
+      : undefined;
+    const provider = typeof model?.provider === "string" ? model.provider.trim() : "";
+    const id = typeof model?.id === "string" ? model.id.trim() : "";
+    if (!provider || !id) continue;
+    return {
+      provider,
+      id,
+      api: typeof model.api === "string" ? model.api.trim() : "",
+      baseUrl: typeof model.baseUrl === "string" ? model.baseUrl.trim() : ""
+    };
+  }
+}
+
+function runPiRpcCommand(command, args, {
+  input = "",
+  maxBuffer = 1024 * 1024,
+  shell = process.platform === "win32",
+  start = spawn,
+  timeout = 20000
+} = {}) {
+  return new Promise((resolve) => {
+    let child;
+    let stdout = "";
+    let settled = false;
+    let timer;
+    const finish = (status) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      child?.stdin?.destroy();
+      child?.stdout?.destroy();
+      child?.stderr?.destroy();
+      if (child?.exitCode === null && child.signalCode === null && !child.killed) child.kill();
+      child?.unref();
+      resolve({ status, stdout });
+    };
+
+    try {
+      const env = { ...process.env };
+      delete env.NODE_TEST_CONTEXT;
+      child = start(command, args, {
+        env,
+        shell,
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      });
+    } catch {
+      finish(null);
+      return;
+    }
+
+    timer = setTimeout(() => finish(null), timeout);
+    child.on("error", () => finish(null));
+    child.on("exit", (code) => finish(code));
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+      if (Buffer.byteLength(stdout, "utf8") > maxBuffer) {
+        finish(null);
+      } else if (parsePiRpcEffectiveModel(stdout)) {
+        finish(0);
+      }
+    });
+    child.stdin.on("error", () => finish(null));
+    child.stdin.write(input, (error) => {
+      if (error) finish(null);
+    });
+  });
+}
+
+async function detectPiEffectiveModel(run = runPiRpcCommand) {
+  let result;
+  try {
+    result = await run("pi", piRpcArgs, {
+      encoding: "utf8",
+      input: `${JSON.stringify({ id: piRpcRequestId, type: "get_state" })}\n`,
+      maxBuffer: 1024 * 1024,
+      shell: process.platform === "win32",
+      timeout: 20000
+    });
+  } catch {
+    return undefined;
+  }
+  if (result?.error || result?.status !== 0) return undefined;
+  return parsePiRpcEffectiveModel(result.stdout);
+}
+
 function parsePiModelIds(value) {
   return [...new Set(String(value || "")
     .split(/[\n,]+/u)
@@ -115,50 +229,106 @@ function getPiApiPromptOptions() {
   ];
 }
 
-function resolveExistingPiApiConfig(modelsConfig = {}, settings = {}, auth = {}) {
-  const provider = modelsConfig.providers?.[piProviderId] && typeof modelsConfig.providers[piProviderId] === "object"
-    ? modelsConfig.providers[piProviderId]
+function resolveExistingPiApiConfig(modelsConfig = {}, settings = {}, auth = {}, effectiveModel) {
+  const savedProviderId = typeof settings.defaultProvider === "string" ? settings.defaultProvider.trim() : "";
+  const savedModelId = typeof settings.defaultModel === "string" ? settings.defaultModel.trim() : "";
+  const effectiveProviderId = typeof effectiveModel?.provider === "string" ? effectiveModel.provider.trim() : "";
+  const effectiveModelId = typeof effectiveModel?.id === "string" ? effectiveModel.id.trim() : "";
+  const savedProvider = savedProviderId
+    && modelsConfig.providers?.[savedProviderId]
+    && typeof modelsConfig.providers[savedProviderId] === "object"
+    ? modelsConfig.providers[savedProviderId]
+    : undefined;
+  const savedModels = Array.isArray(savedProvider?.models) ? savedProvider.models : [];
+  const savedTargetExists = savedProviderId
+    && savedModelId
+    && savedModels.some((model) => model?.id === savedModelId);
+  const providerId = effectiveProviderId && effectiveModelId
+    ? effectiveProviderId
+    : savedTargetExists ? savedProviderId : "";
+  const defaultModel = effectiveProviderId && effectiveModelId
+    ? effectiveModelId
+    : savedTargetExists ? savedModelId : "";
+  const provider = providerId
+    && modelsConfig.providers?.[providerId]
+    && typeof modelsConfig.providers[providerId] === "object"
+    ? modelsConfig.providers[providerId]
     : {};
-  const credential = auth[piProviderId] && typeof auth[piProviderId] === "object"
-    ? auth[piProviderId]
+  const credential = providerId && auth[providerId] && typeof auth[providerId] === "object"
+    ? auth[providerId]
     : {};
   const authApiKey = credential.type === "api_key" && typeof credential.key === "string"
     ? credential.key
     : "";
   const models = Array.isArray(provider.models) ? provider.models.filter((model) => model?.id) : [];
+  const model = models.find((item) => item.id === defaultModel) || {};
+  const runtimeMatches = Boolean(effectiveProviderId
+    && effectiveModelId
+    && effectiveProviderId === providerId
+    && effectiveModelId === defaultModel);
   return {
-    baseUrl: provider.baseUrl || piDefaultBaseUrl,
-    api: provider.api || piDefaultApi,
-    apiKey: authApiKey || provider.apiKey || "",
+    providerId,
+    baseUrl: runtimeMatches && typeof effectiveModel.baseUrl === "string"
+      ? effectiveModel.baseUrl
+      : typeof model.baseUrl === "string" ? model.baseUrl
+        : typeof provider.baseUrl === "string" ? provider.baseUrl : "",
+    api: runtimeMatches && typeof effectiveModel.api === "string"
+      ? effectiveModel.api
+      : typeof model.api === "string" ? model.api
+        : typeof provider.api === "string" ? provider.api : "",
+    apiKey: authApiKey || (typeof provider.apiKey === "string" ? provider.apiKey : ""),
     modelIds: models.map((model) => model.id),
-    defaultModel: settings.defaultProvider === piProviderId && settings.defaultModel
-      ? settings.defaultModel
-      : models[0]?.id || piDefaultModel
+    defaultModel
   };
 }
 
+function assertConfigurablePiProvider(modelsConfig = {}, configuration = {}) {
+  const { providerId, defaultModel, api } = configuration;
+  const provider = modelsConfig.providers?.[providerId];
+  const models = Array.isArray(provider?.models) ? provider.models : [];
+  if (!provider || typeof provider !== "object" || !models.some((model) => model?.id === defaultModel)) {
+    throw new Error(`Pi 当前有效 Provider ${providerId || "未知"} 不是 models.json 中的自定义 Provider；为避免覆盖内置模型，已停止配置。`);
+  }
+  const supportedApis = new Set(getPiApiPromptOptions().map((option) => option.value));
+  if (api && !supportedApis.has(api)) {
+    throw new Error(`Pi 当前有效 Provider ${providerId} 使用不受支持的 API 类型 ${api}；此配置器仅支持 OpenAI-compatible API。`);
+  }
+}
+
 function buildPiModelConfig(modelId, existingModel = {}) {
+  const model = { ...existingModel };
+  delete model.baseUrl;
+  delete model.api;
   return {
-    ...existingModel,
+    ...model,
     id: modelId,
-    name: existingModel.name || modelId,
-    reasoning: existingModel.reasoning ?? true,
-    input: Array.isArray(existingModel.input) ? existingModel.input : ["text", "image"],
-    contextWindow: existingModel.contextWindow ?? 262144,
-    maxTokens: existingModel.maxTokens ?? 64000
+    name: model.name || modelId,
+    reasoning: model.reasoning ?? true,
+    input: Array.isArray(model.input) ? model.input : ["text", "image"],
+    contextWindow: model.contextWindow ?? 262144,
+    maxTokens: model.maxTokens ?? 64000
   };
 }
 
-function hasPiInsecureTlsSetting(modelsConfig = {}) {
-  const headers = modelsConfig.providers?.[piProviderId]?.headers;
+function hasPiInsecureTlsSetting(modelsConfig = {}, providerId) {
+  const headers = modelsConfig.providers?.[requirePiProviderId(providerId)]?.headers;
   return headers && typeof headers === "object"
     ? Object.keys(headers).some((key) => key.toLowerCase() === piInsecureTlsHeader)
     : false;
 }
 
-function buildPiModelsConfig(modelsConfig = {}, { baseUrl, api, modelIds, insecureTls = false }) {
+function buildPiModelsConfig(modelsConfig = {}, {
+  providerId,
+  baseUrl,
+  api,
+  modelIds,
+  insecureTls = false
+}) {
+  const targetProviderId = requirePiProviderId(providerId);
   const providers = modelsConfig.providers && typeof modelsConfig.providers === "object" ? modelsConfig.providers : {};
-  const currentProvider = providers[piProviderId] && typeof providers[piProviderId] === "object" ? providers[piProviderId] : {};
+  const currentProvider = providers[targetProviderId] && typeof providers[targetProviderId] === "object"
+    ? providers[targetProviderId]
+    : {};
   const headers = currentProvider.headers && typeof currentProvider.headers === "object"
     ? { ...currentProvider.headers }
     : {};
@@ -197,16 +367,19 @@ function buildPiModelsConfig(modelsConfig = {}, { baseUrl, api, modelIds, insecu
     ...modelsConfig,
     providers: {
       ...providers,
-      [piProviderId]: provider
+      [targetProviderId]: provider
     }
   };
 }
 
-function buildPiAuthConfig(auth = {}, apiKey) {
-  const credential = auth[piProviderId] && typeof auth[piProviderId] === "object" ? auth[piProviderId] : {};
+function buildPiAuthConfig(auth = {}, providerId, apiKey) {
+  const targetProviderId = requirePiProviderId(providerId);
+  const credential = auth[targetProviderId] && typeof auth[targetProviderId] === "object"
+    ? auth[targetProviderId]
+    : {};
   return {
     ...auth,
-    [piProviderId]: {
+    [targetProviderId]: {
       ...credential,
       type: "api_key",
       key: apiKey
@@ -214,10 +387,10 @@ function buildPiAuthConfig(auth = {}, apiKey) {
   };
 }
 
-function buildPiSettingsConfig(settings = {}, defaultModel) {
+function buildPiSettingsConfig(settings = {}, providerId, defaultModel) {
   return {
     ...settings,
-    defaultProvider: piProviderId,
+    defaultProvider: requirePiProviderId(providerId),
     defaultModel,
     defaultThinkingLevel: settings.defaultThinkingLevel || "high",
     enableSkillCommands: settings.enableSkillCommands ?? true
@@ -235,6 +408,7 @@ async function readExistingPiConfiguration(paths, operations = {}) {
 }
 
 function buildPiConfiguration({ auth, models, settings }, {
+  providerId,
   apiKey,
   baseUrl,
   api,
@@ -242,11 +416,19 @@ function buildPiConfiguration({ auth, models, settings }, {
   insecureTls,
   defaultModel
 }) {
+  const targetProviderId = requirePiProviderId(providerId);
   return {
+    providerId: targetProviderId,
     apiKey,
-    auth: buildPiAuthConfig(auth, apiKey),
-    models: buildPiModelsConfig(models, { baseUrl, api, modelIds, insecureTls }),
-    settings: buildPiSettingsConfig(settings, defaultModel)
+    auth: buildPiAuthConfig(auth, targetProviderId, apiKey),
+    models: buildPiModelsConfig(models, {
+      providerId: targetProviderId,
+      baseUrl,
+      api,
+      modelIds,
+      insecureTls
+    }),
+    settings: buildPiSettingsConfig(settings, targetProviderId, defaultModel)
   };
 }
 
@@ -258,31 +440,55 @@ async function persistPiConfiguration(paths, configuration, operations = {}) {
     { sensitive: true }
   ));
   const writeSettings = operations.writeSettings ?? ((path, value) => writeJsonFileWithBackup(path, value));
-  await updateAuth(paths.piAuthPath, configuration.apiKey);
+  await updateAuth(paths.piAuthPath, configuration.providerId, configuration.apiKey);
   await writeModels(paths.piModelsPath, configuration.models);
   await writeSettings(paths.piSettingsPath, configuration.settings);
 }
 
 async function configurePiApi(paths = defaultPaths, ensurePiResourcesLinked = async () => {}, promptApi, runtime = {}) {
+  const piVersion = await (runtime.getPiVersion ?? detectPiVersion)();
+  try {
+    assertSupportedPiVersion(piVersion);
+  } catch (error) {
+    (runtime.log ?? p.log).warn(error.message || String(error));
+    return;
+  }
   const {
     assertNotCancelled,
     confirmOrCancel,
+    passwordPromptOptions,
     required,
     requiredUnlessExisting,
     resolvePasswordValue,
     selectOrCancel
   } = promptApi;
-  assertSupportedPiVersion(await (runtime.getPiVersion ?? detectPiVersion)());
   const {
     auth,
     models: modelsConfig,
     settings
   } = await readExistingPiConfiguration(paths);
-  const existing = resolveExistingPiApiConfig(modelsConfig, settings, auth);
+  const detectionSpinner = p.spinner();
+  detectionSpinner.start("正在识别 Pi 当前有效模型");
+  let effectiveModel;
+  try {
+    effectiveModel = await (runtime.getPiEffectiveModel ?? detectPiEffectiveModel)();
+  } finally {
+    detectionSpinner.stop(effectiveModel
+      ? `已识别 ${effectiveModel.provider}/${effectiveModel.id}`
+      : "未识别到 Pi 当前有效模型");
+  }
+  const existing = resolveExistingPiApiConfig(modelsConfig, settings, auth, effectiveModel);
+  const providerId = requirePiProviderId(existing.providerId);
+  assertConfigurablePiProvider(modelsConfig, existing);
+  if (effectiveModel
+    && (settings.defaultProvider !== existing.providerId || settings.defaultModel !== existing.defaultModel)) {
+    p.log.warn(`Pi 保存的默认模型 ${settings.defaultProvider || "未知"}/${settings.defaultModel || "未知"} 与当前有效模型 ${existing.providerId}/${existing.defaultModel} 不同；将配置当前有效模型。`);
+  }
+  const providerLabel = `Pi ${providerId}`;
 
   const baseUrlInput = await p.text({
-    message: "Pi gpt Base URL",
-    defaultValue: existing.baseUrl,
+    message: `${providerLabel} Base URL`,
+    initialValue: existing.baseUrl,
     validate: required()
   });
   assertNotCancelled(baseUrlInput);
@@ -290,29 +496,33 @@ async function configurePiApi(paths = defaultPaths, ensurePiResourcesLinked = as
   const baseUrl = normalizeOpenAiBaseUrl(baseUrlInput);
 
   const insecureTls = await confirmOrCancel({
-    message: "是否仅为 Pi gpt 中转请求跳过 TLS 证书校验？仅证书无法修复时启用",
-    initialValue: hasPiInsecureTlsSetting(modelsConfig)
+    message: `是否仅为 ${providerLabel} 中转请求跳过 TLS 证书校验？仅证书无法修复时启用`,
+    initialValue: hasPiInsecureTlsSetting(modelsConfig, providerId)
   });
 
   const piApiOptions = getPiApiPromptOptions();
+  const initialApi = piApiOptions.some((option) => option.value === existing.api)
+    ? existing.api
+    : undefined;
   const api = inferredApi || await selectOrCancel({
-    message: "Pi gpt API 类型",
+    message: `${providerLabel} API 类型`,
     options: piApiOptions,
-    initialValue: piApiOptions.some((option) => option.value === existing.api) ? existing.api : piDefaultApi
+    ...(initialApi ? { initialValue: initialApi } : {})
   });
 
-  const apiKey = await p.password({
-    message: "Pi gpt API Key（输入 - 清除）",
-    mask: "*",
-    defaultValue: existing.apiKey || undefined,
-    validate: requiredUnlessExisting(existing.apiKey, "API Key 不能为空")
-  });
+  const apiKey = await p.password(passwordPromptOptions(
+    `${providerLabel} API Key`,
+    existing.apiKey,
+    requiredUnlessExisting(existing.apiKey, "API Key 不能为空")
+  ));
   assertNotCancelled(apiKey);
   const finalApiKey = resolvePasswordValue(apiKey, existing.apiKey);
 
   const modelIdsText = await p.text({
-    message: "Pi gpt 模型 ID（多个用逗号分隔）",
-    defaultValue: (existing.modelIds.length ? existing.modelIds : [existing.defaultModel]).join(","),
+    message: `${providerLabel} 模型 ID（多个用逗号分隔）`,
+    initialValue: (existing.modelIds.length
+      ? existing.modelIds
+      : existing.defaultModel ? [existing.defaultModel] : []).join(","),
     validate: (value) => parsePiModelIds(value).length ? undefined : "至少需要一个模型 ID"
   });
   assertNotCancelled(modelIdsText);
@@ -320,13 +530,14 @@ async function configurePiApi(paths = defaultPaths, ensurePiResourcesLinked = as
 
   const defaultModel = await p.text({
     message: "Pi 默认模型",
-    defaultValue: modelIds.includes(existing.defaultModel) ? existing.defaultModel : modelIds[0],
+    initialValue: modelIds.includes(existing.defaultModel) ? existing.defaultModel : modelIds[0],
     validate: (value) => modelIds.includes(String(value || "").trim()) ? undefined : "默认模型必须在模型 ID 列表中"
   });
   assertNotCancelled(defaultModel);
 
   const finalDefaultModel = String(defaultModel).trim();
   const configuration = buildPiConfiguration({ auth, models: modelsConfig, settings }, {
+    providerId,
     apiKey: finalApiKey,
     baseUrl,
     api,
@@ -337,26 +548,30 @@ async function configurePiApi(paths = defaultPaths, ensurePiResourcesLinked = as
   await ensurePiResourcesLinked(paths);
   await persistPiConfiguration(paths, configuration);
 
-  p.log.step(`已更新 ${pathToLabel(paths.piModelsPath, paths.homeDir)} (${piProviderId}, ${baseUrl})`);
+  p.log.step(`已更新 ${pathToLabel(paths.piModelsPath, paths.homeDir)} (${providerId}, ${baseUrl})`);
   p.log.step(`已更新 ${pathToLabel(paths.piSettingsPath, paths.homeDir)} (默认模型: ${finalDefaultModel})`);
   p.log.step(`已更新 ${pathToLabel(paths.piAuthPath, paths.homeDir)} (${maskSecret(finalApiKey)})`);
   p.log.step(`已链接 Pi 扩展到 ${pathToLabel(join(paths.piAgentDir, "extensions"), paths.homeDir)}`);
 }
 
 export {
+  assertConfigurablePiProvider,
   assertSupportedPiVersion,
   buildPiAuthConfig,
   buildPiConfiguration,
   buildPiModelsConfig,
   buildPiSettingsConfig,
   configurePiApi,
+  detectPiEffectiveModel,
   getPiApiPromptOptions,
   hasPiInsecureTlsSetting,
   inferPiApiFromBaseUrl,
   normalizeOpenAiBaseUrl,
+  parsePiRpcEffectiveModel,
   parsePiModelIds,
   persistPiConfiguration,
   readExistingPiConfiguration,
   resolveExistingPiApiConfig,
+  runPiRpcCommand,
   updatePiAuthFile
 };

package/lib/providers/skills.mjs

@@ -17,30 +17,36 @@ async function updateSkillEnvFile(path, updates) {
   return updateDotenvFile(path, updates, { sensitive: true });
 }
 
-async function configureGrokSearchEnv(paths, ensureWorkflowPresent = async () => {}, promptApi) {
-  const { assertNotCancelled, confirmOrCancel, required, requiredUnlessExisting, resolvePasswordValue } = promptApi;
-  await ensureWorkflowPresent(paths);
+async function configureGrokSearchEnv(paths, ensureSkillPresent = async () => {}, promptApi) {
+  const {
+    assertNotCancelled,
+    confirmOrCancel,
+    passwordPromptOptions,
+    required,
+    requiredUnlessExisting,
+    resolvePasswordValue
+  } = promptApi;
+  await ensureSkillPresent(paths);
   const envPath = join(paths.agentsDir, "skills", "grok-search", ".env");
   const existing = await readSkillEnvFile(envPath);
   const baseUrl = await p.text({
     message: "Grok API URL",
-    defaultValue: existing.GROK_API_URL || "https://api.x.ai/v1",
+    initialValue: existing.GROK_API_URL || "https://api.x.ai/v1",
     validate: required()
   });
   assertNotCancelled(baseUrl);
 
-  const apiKey = await p.password({
-    message: "Grok API Key（输入 - 清除）",
-    mask: "*",
-    defaultValue: existing.GROK_API_KEY || undefined,
-    validate: requiredUnlessExisting(existing.GROK_API_KEY, "Grok API Key 不能为空")
-  });
+  const apiKey = await p.password(passwordPromptOptions(
+    "Grok API Key",
+    existing.GROK_API_KEY,
+    requiredUnlessExisting(existing.GROK_API_KEY, "Grok API Key 不能为空")
+  ));
   assertNotCancelled(apiKey);
   const finalApiKey = resolvePasswordValue(apiKey, existing.GROK_API_KEY);
 
   const model = await p.text({
     message: "Grok 默认模型",
-    defaultValue: existing.GROK_MODEL || grokDefaults.model,
+    initialValue: existing.GROK_MODEL || grokDefaults.model,
     validate: required()
   });
   assertNotCancelled(model);
@@ -51,12 +57,11 @@ async function configureGrokSearchEnv(paths, ensureWorkflowPresent = async () =>
   });
 
   const tavilyKey = useTavily
-    ? await p.password({
-        message: "Tavily API Key（输入 - 清除）",
-        mask: "*",
-        defaultValue: existing.TAVILY_API_KEY || undefined,
-        validate: requiredUnlessExisting(existing.TAVILY_API_KEY, "Tavily API Key 不能为空")
-      })
+    ? await p.password(passwordPromptOptions(
+        "Tavily API Key",
+        existing.TAVILY_API_KEY,
+        requiredUnlessExisting(existing.TAVILY_API_KEY, "Tavily API Key 不能为空")
+      ))
     : "";
   if (useTavily) assertNotCancelled(tavilyKey);
   const finalTavilyKey = useTavily ? resolvePasswordValue(tavilyKey, existing.TAVILY_API_KEY) : null;
@@ -72,16 +77,15 @@ async function configureGrokSearchEnv(paths, ensureWorkflowPresent = async () =>
   p.log.step(`已写入 ${pathToLabel(envPath)}`);
 }
 
-async function configureContext7Env(paths, ensureWorkflowPresent = async () => {}, promptApi) {
-  const { assertNotCancelled, resolvePasswordValue } = promptApi;
-  await ensureWorkflowPresent(paths);
+async function configureContext7Env(paths, ensureSkillPresent = async () => {}, promptApi) {
+  const { assertNotCancelled, passwordPromptOptions, resolvePasswordValue } = promptApi;
+  await ensureSkillPresent(paths);
   const envPath = join(paths.agentsDir, "skills", "context7-auto-research", ".env");
   const existing = await readSkillEnvFile(envPath);
-  const apiKey = await p.password({
-    message: "Context7 API Key (可选，输入 - 清除)",
-    mask: "*",
-    defaultValue: existing.CONTEXT7_API_KEY || undefined
-  });
+  const apiKey = await p.password(passwordPromptOptions(
+    "Context7 API Key（可选）",
+    existing.CONTEXT7_API_KEY
+  ));
   assertNotCancelled(apiKey);
   const finalApiKey = resolvePasswordValue(apiKey, existing.CONTEXT7_API_KEY);
 
@@ -92,73 +96,10 @@ async function configureContext7Env(paths, ensureWorkflowPresent = async () => {
   p.log.step(`已写入 ${pathToLabel(envPath)}`);
 }
 
-function hasPromptEnhancerApiConfig(config) {
-  return [config.PE_API_URL, config.PE_API_KEY, config.PE_MODEL]
-    .every((value) => typeof value === "string" && value.trim() !== "");
-}
-
-function resolvePromptEnhancerMode(existing) {
-  return hasPromptEnhancerApiConfig(existing) ? "openai-compatible" : "agent";
-}
-
-function buildPromptEnhancerEnvUpdates(apiUrl = null, apiKey = null, model = null) {
-  return { PE_API_URL: apiUrl, PE_API_KEY: apiKey, PE_MODEL: model };
-}
-
-async function configurePromptEnhancerEnv(paths, ensureWorkflowPresent = async () => {}, promptApi) {
-  const { assertNotCancelled, required, requiredUnlessExisting, resolvePasswordValue, selectOrCancel } = promptApi;
-  await ensureWorkflowPresent(paths);
-  const envPath = join(paths.agentsDir, "skills", "prompt-enhancer", ".env");
-  const existing = await readSkillEnvFile(envPath);
-  const mode = await selectOrCancel({
-    message: "请选择 prompt-enhancer 的运行方式",
-    options: [
-      { value: "openai-compatible", label: "第三方 OpenAI 兼容接口" },
-      { value: "agent", label: "直接使用当前 Agent" }
-    ],
-    initialValue: resolvePromptEnhancerMode(existing)
-  });
-
-  if (mode === "openai-compatible") {
-    const apiUrl = await p.text({
-      message: "PE_API_URL",
-      defaultValue: existing.PE_API_URL || undefined,
-      validate: required()
-    });
-    assertNotCancelled(apiUrl);
-
-    const apiKey = await p.password({
-      message: "PE_API_KEY（输入 - 清除）",
-      mask: "*",
-      defaultValue: existing.PE_API_KEY || undefined,
-      validate: requiredUnlessExisting(existing.PE_API_KEY, "PE_API_KEY 不能为空")
-    });
-    assertNotCancelled(apiKey);
-    const finalApiKey = resolvePasswordValue(apiKey, existing.PE_API_KEY);
-
-    const model = await p.text({
-      message: "PE_MODEL",
-      defaultValue: existing.PE_MODEL || undefined,
-      validate: required()
-    });
-    assertNotCancelled(model);
-
-    await updateSkillEnvFile(envPath, buildPromptEnhancerEnvUpdates(apiUrl, finalApiKey, model));
-  } else {
-    await updateSkillEnvFile(envPath, buildPromptEnhancerEnvUpdates());
-  }
-
-  p.log.step(`已写入 ${pathToLabel(envPath)}`);
-}
-
 export {
-  buildPromptEnhancerEnvUpdates,
   configureContext7Env,
   configureGrokSearchEnv,
-  configurePromptEnhancerEnv,
   grokDefaults,
-  hasPromptEnhancerApiConfig,
   readSkillEnvFile,
-  resolvePromptEnhancerMode,
   updateSkillEnvFile
 };