abelworkflow 1.1.3 → 1.2.0

package/lib/providers/pi.mjs

@@ -1,198 +1,14 @@
-import { spawn, spawnSync } from "node:child_process";
-import { join } from "node:path";
 import * as p from "@clack/prompts";
 import {
+  assertPlainObject,
   readJsonFileSafe,
   readJsoncFileSafe,
-  updateLockedJson,
-  writeJson,
-  writeText
+  withFileTransaction
 } from "../config/store.mjs";
-import { defaultPaths, maskSecret, pathToLabel } from "../paths.mjs";
+import { normalizeOpenAiBaseUrl } from "./url.mjs";
+import { stripJsonComments } from "../config/jsonc.mjs";
 
-const minimumPiVersion = [0, 80, 0];
-const piBootstrapProviderId = "gpt";
-const piBootstrapApi = "openai-completions";
-const piBootstrapBaseUrl = "https://api.openai.com/v1";
-const piBootstrapModelId = "gpt-5.5";
-const piRpcRequestId = "abelworkflow-provider";
-const piRpcArgs = [
-  "--mode", "rpc",
-  "--no-session",
-  "--offline",
-  "--no-context-files",
-  "--no-skills",
-  "--no-prompt-templates",
-  "--no-themes"
-];
-
-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, targetProviderId, apiKey);
-  }, {
-    sensitive: true,
-    retries: {
-      retries: 10,
-      factor: 2,
-      minTimeout: 100,
-      maxTimeout: 10000,
-      randomize: true
-    }
-  });
-}
-
-function parsePiVersion(value) {
-  const match = String(value || "").match(/(?:^|\D)v?(\d+)\.(\d+)\.(\d+)(?:\D|$)/u);
-  return match ? match.slice(1).map(Number) : null;
-}
-
-function assertSupportedPiVersion(value) {
-  const version = parsePiVersion(value);
-  if (!version) {
-    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 或更高版本。`);
-    }
-  }
-  return version;
-}
-
-function getPiProcessInvocation(args, {
-  platform = process.platform,
-  comspec = process.env.ComSpec || process.env.COMSPEC || "cmd.exe"
-} = {}) {
-  return platform === "win32"
-    ? { command: comspec, args: ["/d", "/c", "pi", ...args] }
-    : { command: "pi", args };
-}
-
-function detectPiVersion() {
-  const invocation = getPiProcessInvocation(["--version"]);
-  const result = spawnSync(invocation.command, invocation.args, {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  return result.status === 0 ? `${result.stdout || ""} ${result.stderr || ""}`.trim() : undefined;
-}
-
-function isPiUnknownModel(model) {
-  return model?.provider === "unknown" && model?.id === "unknown" && model?.api === "unknown";
-}
-
-function parsePiRpcEffectiveModel(value) {
-  for (const line of String(value || "").split(/\r?\n/u)) {
-    let payload;
-    try {
-      payload = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (payload?.type !== "response"
-      || payload.command !== "get_state"
-      || payload.success !== true) continue;
-    const model = payload.data?.model;
-    if (model === null) return null;
-    const effectiveModel = {
-      provider: typeof model?.provider === "string" ? model.provider.trim() : "",
-      id: typeof model?.id === "string" ? model.id.trim() : "",
-      api: typeof model?.api === "string" ? model.api.trim() : "",
-      baseUrl: typeof model?.baseUrl === "string" ? model.baseUrl.trim() : ""
-    };
-    if (isPiUnknownModel(effectiveModel)) return null;
-    if (effectiveModel.provider && effectiveModel.id) return effectiveModel;
-  }
-}
-
-function runPiRpcCommand(command, args, {
-  input = "",
-  maxBuffer = 1024 * 1024,
-  platform = process.platform,
-  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;
-      const invocation = command === "pi"
-        ? getPiProcessInvocation(args, { platform })
-        : { command, args };
-      child = start(invocation.command, invocation.args, {
-        env,
-        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) !== undefined) {
-        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,
-      platform: process.platform,
-      timeout: 20000
-    });
-  } catch {
-    return undefined;
-  }
-  if (result?.error || result?.status !== 0) return undefined;
-  return parsePiRpcEffectiveModel(result.stdout);
-}
+const piProviderId = "abelworkflow";
 
 function parsePiModelIds(value) {
   return [...new Set(String(value || "")
@@ -202,43 +18,20 @@ function parsePiModelIds(value) {
 }
 
 function getOpenAiUrlPathname(value) {
-  const input = String(value || "").trim();
   try {
-    return new URL(input).pathname.replace(/\/+$/u, "");
+    return new URL(String(value || "").trim()).pathname.replace(/\/+$/u, "");
   } catch {
-    return input.split(/[?#]/u)[0].replace(/\/+$/u, "");
+    return "";
   }
 }
 
 function inferPiApiFromBaseUrl(value) {
   const pathname = getOpenAiUrlPathname(value);
-  if (pathname.endsWith("/v1/chat/completions")) {
-    return "openai-completions";
-  }
-  if (pathname.endsWith("/v1/responses")) {
-    return "openai-responses";
-  }
+  if (pathname.endsWith("/v1/chat/completions")) return "openai-completions";
+  if (pathname.endsWith("/v1/responses")) return "openai-responses";
   return null;
 }
 
-function normalizeOpenAiBaseUrl(value) {
-  const input = String(value || "").trim();
-  try {
-    const url = new URL(input);
-    let pathname = url.pathname.replace(/\/+$/u, "")
-      .replace(/\/v1\/(?:chat\/completions|responses)$/u, "/v1");
-    if (!pathname.endsWith("/v1")) {
-      pathname = `${pathname}/v1`;
-    }
-    url.pathname = pathname;
-    return url.toString();
-  } catch {
-    const baseUrl = input.replace(/\/+$/u, "")
-      .replace(/\/v1\/(?:chat\/completions|responses)$/u, "/v1");
-    return baseUrl.endsWith("/v1") ? baseUrl : `${baseUrl}/v1`;
-  }
-}
-
 function getPiApiPromptOptions() {
   return [
     { value: "openai-completions", label: "OpenAI Chat Completions（推荐）" },
@@ -246,351 +39,392 @@ function getPiApiPromptOptions() {
   ];
 }
 
-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 = providerId && auth[providerId] && typeof auth[providerId] === "object"
-    ? auth[providerId]
-    : {};
-  const authApiKey = credential.type === "api_key" && typeof credential.key === "string"
-    ? credential.key
+function resolveExistingPiApiConfig(modelsConfig = {}, settings = {}, auth = {}) {
+  assertPlainObject(modelsConfig, "Pi models");
+  assertPlainObject(settings, "Pi settings");
+  assertPlainObject(auth, "Pi auth");
+  const providers = modelsConfig.providers === undefined
+    ? {}
+    : assertPlainObject(modelsConfig.providers, "Pi models providers");
+  const provider = providers[piProviderId];
+  const target = provider === undefined ? {} : assertPlainObject(provider, `Pi provider ${piProviderId}`);
+  const models = Array.isArray(target.models) ? target.models.filter((model) => model?.id) : [];
+  const modelIds = models.map((model) => model.id);
+  const savedModel = settings.defaultProvider === piProviderId
+    && modelIds.includes(settings.defaultModel)
+    ? settings.defaultModel
     : "";
-  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 {
-    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
-  };
-}
-
-function resolvePiApiTarget(modelsConfig = {}, settings = {}, auth = {}, effectiveModel) {
-  const hasNoEffectiveModel = effectiveModel === null || isPiUnknownModel(effectiveModel);
-  const configuration = resolveExistingPiApiConfig(
-    modelsConfig,
-    settings,
-    auth,
-    hasNoEffectiveModel ? undefined : effectiveModel
-  );
-  if (configuration.providerId || !hasNoEffectiveModel) {
-    return { bootstrap: false, configuration };
-  }
-
-  const provider = modelsConfig.providers?.[piBootstrapProviderId];
-  const models = Array.isArray(provider?.models) ? provider.models.filter((model) => model?.id) : [];
-  const credential = auth[piBootstrapProviderId];
-  const apiKey = credential?.type === "api_key" && typeof credential.key === "string"
+  const credential = auth[piProviderId];
+  const authApiKey = credential?.type === "api_key" && typeof credential.key === "string"
     ? credential.key
-    : typeof provider?.apiKey === "string" ? provider.apiKey : "";
-  return {
-    bootstrap: true,
-    configuration: {
-      providerId: piBootstrapProviderId,
-      baseUrl: typeof provider?.baseUrl === "string" ? provider.baseUrl : piBootstrapBaseUrl,
-      api: typeof provider?.api === "string" ? provider.api : piBootstrapApi,
-      apiKey,
-      modelIds: models.map((model) => model.id),
-      defaultModel: models[0]?.id || piBootstrapModelId
-    }
-  };
-}
-
-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 {
-    ...model,
-    id: modelId,
-    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
+    baseUrl: typeof target.baseUrl === "string" ? target.baseUrl : "",
+    api: typeof target.api === "string" ? target.api : "",
+    apiKey: authApiKey,
+    modelIds,
+    defaultModel: savedModel || modelIds[0] || ""
   };
 }
 
-function buildPiModelsConfig(modelsConfig = {}, {
-  providerId,
-  baseUrl,
-  api,
-  modelIds
-}) {
-  const targetProviderId = requirePiProviderId(providerId);
-  const providers = modelsConfig.providers && typeof modelsConfig.providers === "object" ? modelsConfig.providers : {};
-  const currentProvider = providers[targetProviderId] && typeof providers[targetProviderId] === "object"
-    ? providers[targetProviderId]
-    : {};
+function buildPiModelsConfig(modelsConfig = {}, { baseUrl, api, apiKey, modelIds }) {
+  assertPlainObject(modelsConfig, "Pi models");
+  const providers = modelsConfig.providers === undefined
+    ? {}
+    : assertPlainObject(modelsConfig.providers, "Pi models providers");
+  const currentProvider = providers[piProviderId] === undefined
+    ? {}
+    : assertPlainObject(providers[piProviderId], `Pi provider ${piProviderId}`);
   const existingModels = new Map(
     (Array.isArray(currentProvider.models) ? currentProvider.models : [])
       .filter((model) => model?.id)
       .map((model) => [model.id, model])
   );
-
+  const responses = api === "openai-responses";
   const provider = {
-    ...currentProvider,
-    baseUrl,
+    baseUrl: normalizeOpenAiBaseUrl(baseUrl),
     api,
-    compat: {
-      ...(currentProvider.compat && typeof currentProvider.compat === "object" ? currentProvider.compat : {}),
-      supportsDeveloperRole: false
-    },
-    models: modelIds.map((modelId) => buildPiModelConfig(modelId, existingModels.get(modelId)))
+    ...(responses ? {
+      apiKey,
+      compat: { supportsDeveloperRole: false }
+    } : {}),
+    models: modelIds.map((modelId) => {
+      const name = existingModels.get(modelId)?.name;
+      const model = { id: modelId, name: typeof name === "string" && name ? name : modelId };
+      return responses ? {
+        ...model,
+        reasoning: true,
+        input: ["text", "image"],
+        thinkingLevelMap: {
+          off: null,
+          minimal: null,
+          low: null,
+          medium: null,
+          high: null,
+          xhigh: null,
+          max: "max"
+        },
+        contextWindow: 262144,
+        maxTokens: 131072
+      } : model;
+    })
   };
-  delete provider.apiKey;
 
   return {
     ...modelsConfig,
     providers: {
       ...providers,
-      [targetProviderId]: provider
+      [piProviderId]: provider
     }
   };
 }
 
-function buildPiAuthConfig(auth = {}, providerId, apiKey) {
-  const targetProviderId = requirePiProviderId(providerId);
-  const credential = auth[targetProviderId] && typeof auth[targetProviderId] === "object"
-    ? auth[targetProviderId]
-    : {};
-  return {
-    ...auth,
-    [targetProviderId]: {
-      ...credential,
-      type: "api_key",
-      key: apiKey
-    }
-  };
+function buildPiAuthConfig(auth = {}, apiKey) {
+  assertPlainObject(auth, "Pi auth");
+  const nextAuth = { ...auth };
+  if (!apiKey) {
+    delete nextAuth[piProviderId];
+    return nextAuth;
+  }
+  const credential = auth[piProviderId] === undefined
+    ? {}
+    : assertPlainObject(auth[piProviderId], `Pi credential ${piProviderId}`);
+  nextAuth[piProviderId] = { ...credential, type: "api_key", key: apiKey };
+  return nextAuth;
 }
 
-function buildPiSettingsConfig(settings = {}, providerId, defaultModel) {
+function buildPiSettingsConfig(settings = {}, defaultModel) {
+  assertPlainObject(settings, "Pi settings");
   return {
     ...settings,
-    defaultProvider: requirePiProviderId(providerId),
-    defaultModel,
-    defaultThinkingLevel: settings.defaultThinkingLevel || "high",
-    enableSkillCommands: settings.enableSkillCommands ?? true
+    defaultProvider: piProviderId,
+    defaultModel
   };
 }
 
 async function readExistingPiConfiguration(paths, operations = {}) {
-  const readAuth = operations.readAuth ?? ((path) => readJsonFileSafe(path, {}, { sensitive: true }));
-  const readModels = operations.readModels ?? ((path) => readJsoncFileSafe(path, {}, { sensitive: true }));
-  const readSettings = operations.readSettings ?? ((path) => readJsonFileSafe(path, {}));
+  const readAuth = operations.readAuth ?? ((path) => readJsonFileSafe(path, {}, {
+    safeRoot: paths.homeDir,
+    sensitive: true
+  }));
+  const readModels = operations.readModels ?? ((path) => readJsoncFileSafe(path, {}, {
+    safeRoot: paths.homeDir,
+    sensitive: true
+  }));
+  const readSettings = operations.readSettings ?? ((path) => readJsonFileSafe(path, {}, {
+    safeRoot: paths.homeDir
+  }));
   const auth = await readAuth(paths.piAuthPath);
   const models = await readModels(paths.piModelsPath);
   const settings = await readSettings(paths.piSettingsPath);
+  assertPlainObject(auth, "Pi auth");
+  assertPlainObject(models, "Pi models");
+  assertPlainObject(settings, "Pi settings");
   return { auth, models, settings };
 }
 
-function buildPiConfiguration({ auth, models, settings }, {
-  providerId,
-  apiKey,
-  baseUrl,
-  api,
-  modelIds,
-  defaultModel
-}) {
-  const targetProviderId = requirePiProviderId(providerId);
-  return {
-    providerId: targetProviderId,
-    apiKey,
-    auth: buildPiAuthConfig(auth, targetProviderId, apiKey),
-    models: buildPiModelsConfig(models, {
-      providerId: targetProviderId,
-      baseUrl,
-      api,
-      modelIds
-    }),
-    settings: buildPiSettingsConfig(settings, targetProviderId, defaultModel)
-  };
+function skipJsoncTrivia(content, index) {
+  while (index < content.length) {
+    if (/\s/u.test(content[index])) {
+      index += 1;
+    } else if (content.startsWith("//", index)) {
+      index = content.indexOf("\n", index + 2);
+      if (index === -1) return content.length;
+    } else if (content.startsWith("/*", index)) {
+      const end = content.indexOf("*/", index + 2);
+      if (end === -1) throw new SyntaxError("Unterminated JSONC block comment");
+      index = end + 2;
+    } else {
+      break;
+    }
+  }
+  return index;
 }
 
-async function persistPiConfiguration(paths, configuration, operations = {}) {
-  const updateAuth = operations.updateAuth ?? updatePiAuthFile;
-  const writeModels = operations.writeModels ?? ((path, value) => writeText(
-    path,
-    `${JSON.stringify(value, null, 2)}\n`,
-    { sensitive: true }
-  ));
-  const writeSettings = operations.writeSettings ?? ((path, value) => writeJson(path, value));
-  await updateAuth(paths.piAuthPath, configuration.providerId, configuration.apiKey);
-  await writeModels(paths.piModelsPath, configuration.models);
-  await writeSettings(paths.piSettingsPath, configuration.settings);
+function parseJsoncStringNode(content, index) {
+  const start = index;
+  index += 1;
+  while (index < content.length) {
+    if (content[index] === "\\") index += 2;
+    else if (content[index] === '"') {
+      index += 1;
+      return {
+        end: index,
+        start,
+        type: "string",
+        value: JSON.parse(content.slice(start, index))
+      };
+    } else index += 1;
+  }
+  throw new SyntaxError("Unterminated JSON string");
 }
 
-async function configurePiApi(paths = defaultPaths, ensurePiResourcesLinked = async () => {}, promptApi, runtime = {}) {
-  const log = runtime.log ?? p.log;
-  const spinner = runtime.spinner ?? p.spinner;
-  const text = runtime.text ?? p.text;
-  const piVersion = await (runtime.getPiVersion ?? detectPiVersion)();
-  try {
-    assertSupportedPiVersion(piVersion);
-  } catch (error) {
-    log.warn(error.message || String(error));
-    return;
+function parseJsoncNode(content, startIndex = 0) {
+  let index = skipJsoncTrivia(content, startIndex);
+  const start = index;
+  if (content[index] === '"') return parseJsoncStringNode(content, index);
+  if (content[index] === "{") {
+    index += 1;
+    const properties = [];
+    while (true) {
+      index = skipJsoncTrivia(content, index);
+      if (content[index] === "}") {
+        return { end: index + 1, properties, start, type: "object" };
+      }
+      const key = parseJsoncStringNode(content, index);
+      index = skipJsoncTrivia(content, key.end);
+      if (content[index] !== ":") throw new SyntaxError("Invalid JSONC object property");
+      const value = parseJsoncNode(content, index + 1);
+      index = skipJsoncTrivia(content, value.end);
+      let comma = false;
+      if (content[index] === ",") {
+        comma = true;
+        index += 1;
+      }
+      properties.push({ comma, key, value });
+      if (!comma) {
+        index = skipJsoncTrivia(content, index);
+        if (content[index] !== "}") throw new SyntaxError("Invalid JSONC object");
+      }
+    }
   }
-  const {
-    assertNotCancelled,
-    passwordOrExisting,
-    required,
-    selectOrCancel
-  } = promptApi;
-  const {
-    auth,
-    models: modelsConfig,
-    settings
-  } = await readExistingPiConfiguration(paths);
-  const detectionSpinner = spinner();
-  detectionSpinner.start("正在识别 Pi 当前有效模型");
-  let effectiveModel;
-  try {
-    effectiveModel = await (runtime.getPiEffectiveModel ?? detectPiEffectiveModel)();
-  } finally {
-    detectionSpinner.stop(effectiveModel
-      ? `已识别 ${effectiveModel.provider}/${effectiveModel.id}`
-      : "未识别到 Pi 当前有效模型");
+  if (content[index] === "[") {
+    index += 1;
+    while (true) {
+      index = skipJsoncTrivia(content, index);
+      if (content[index] === "]") return { end: index + 1, start, type: "array" };
+      const value = parseJsoncNode(content, index);
+      index = skipJsoncTrivia(content, value.end);
+      if (content[index] === ",") index += 1;
+      else if (content[index] !== "]") throw new SyntaxError("Invalid JSONC array");
+    }
   }
-  const target = resolvePiApiTarget(modelsConfig, settings, auth, effectiveModel);
-  const existing = target.configuration;
-  const providerId = requirePiProviderId(existing.providerId);
-  if (target.bootstrap) {
-    log.info(`Pi 尚未配置可用模型，将创建自定义 Provider ${providerId}。`);
-  } else {
-    assertConfigurablePiProvider(modelsConfig, existing);
+  while (index < content.length
+    && !/[\s,\]}]/u.test(content[index])
+    && !content.startsWith("//", index)
+    && !content.startsWith("/*", index)) {
+    index += 1;
   }
-  if (effectiveModel
-    && (settings.defaultProvider !== existing.providerId || settings.defaultModel !== existing.defaultModel)) {
-    log.warn(`Pi 保存的默认模型 ${settings.defaultProvider || "未知"}/${settings.defaultModel || "未知"} 与当前有效模型 ${existing.providerId}/${existing.defaultModel} 不同；将配置当前有效模型。`);
+  if (index === start) throw new SyntaxError("Invalid JSONC value");
+  return { end: index, start, type: "scalar" };
+}
+
+function lineIndentAt(content, index) {
+  const lineStart = content.lastIndexOf("\n", index - 1) + 1;
+  return content.slice(lineStart, index).match(/^[ \t]*/u)?.[0] ?? "";
+}
+
+function formatJsoncValue(value, indent, lineEnding) {
+  return JSON.stringify(value, null, 2).replace(/\n/gu, `${lineEnding}${indent}`);
+}
+
+function findJsoncProperty(objectNode, key) {
+  return objectNode.properties.find((property) => property.key.value === key);
+}
+
+function findUniqueJsoncProperty(objectNode, key, label) {
+  const matches = objectNode.properties.filter((property) => property.key.value === key);
+  if (matches.length > 1) throw new SyntaxError(`Duplicate Pi ${label} key`);
+  return matches[0];
+}
+
+function setJsoncObjectProperty(content, objectNode, key, value) {
+  const existing = findJsoncProperty(objectNode, key);
+  const lineEnding = content.includes("\r\n") ? "\r\n" : "\n";
+  if (existing) {
+    const indent = lineIndentAt(content, existing.key.start);
+    return `${content.slice(0, existing.value.start)}${formatJsoncValue(value, indent, lineEnding)}${content.slice(existing.value.end)}`;
   }
-  const providerLabel = `Pi ${providerId}`;
 
-  const baseUrlInput = await text({
-    message: `${providerLabel} Base URL`,
-    initialValue: existing.baseUrl,
-    validate: required()
-  });
-  assertNotCancelled(baseUrlInput);
-  const inferredApi = inferPiApiFromBaseUrl(baseUrlInput);
-  const baseUrl = normalizeOpenAiBaseUrl(baseUrlInput);
+  const close = objectNode.end - 1;
+  let insertionPoint = close;
+  while (insertionPoint > objectNode.start && /[ \t]/u.test(content[insertionPoint - 1])) insertionPoint -= 1;
+  const objectIndent = lineIndentAt(content, objectNode.start);
+  const childIndent = objectNode.properties.length
+    ? lineIndentAt(content, objectNode.properties[0].key.start)
+    : `${objectIndent}  `;
+  const last = objectNode.properties.at(-1);
+  const needsComma = last && !last.comma;
+  const gapStart = last?.value.end ?? objectNode.start + 1;
+  const gap = content.slice(gapStart, insertionPoint);
+  const needsLineBreak = !gap.includes("\n") && !gap.includes("\r");
+  const property = `${childIndent}${JSON.stringify(key)}: ${formatJsoncValue(value, childIndent, lineEnding)}${lineEnding}`;
+  return `${content.slice(0, gapStart)}${needsComma ? "," : ""}${gap}${needsLineBreak ? lineEnding : ""}${property}${content.slice(insertionPoint)}`;
+}
 
-  const piApiOptions = getPiApiPromptOptions();
-  const initialApi = piApiOptions.some((option) => option.value === existing.api)
-    ? existing.api
-    : undefined;
-  const api = inferredApi || await selectOrCancel({
-    message: `${providerLabel} API 类型`,
-    options: piApiOptions,
-    ...(initialApi ? { initialValue: initialApi } : {})
-  });
+function updatePiModelsContent(content, provider) {
+  const root = parseJsoncNode(content);
+  if (root.type !== "object") throw new TypeError("Pi models must contain a JSON object");
+  const providersProperty = findUniqueJsoncProperty(root, "providers", "providers");
+  if (!providersProperty) {
+    return setJsoncObjectProperty(content, root, "providers", { [piProviderId]: provider });
+  }
+  if (providersProperty.value.type !== "object") {
+    throw new TypeError("Pi models providers must contain a JSON object");
+  }
+  findUniqueJsoncProperty(providersProperty.value, piProviderId, `providers.${piProviderId}`);
+  return setJsoncObjectProperty(content, providersProperty.value, piProviderId, provider);
+}
 
-  const finalApiKey = await passwordOrExisting({
-    message: `${providerLabel} API Key`,
-    existingValue: existing.apiKey
+async function persistPiConfiguration(paths, intent, operations = {}) {
+  return withFileTransaction([
+    { path: paths.piAuthPath, safeRoot: paths.homeDir, sensitive: true },
+    { path: paths.piModelsPath, safeRoot: paths.homeDir, sensitive: true },
+    { path: paths.piSettingsPath, safeRoot: paths.homeDir }
+  ], async (transaction) => {
+    const auth = transaction.readJson(paths.piAuthPath, {});
+    const models = transaction.readJson(paths.piModelsPath, {}, { jsonc: true });
+    const settings = transaction.readJson(paths.piSettingsPath, {});
+    assertPlainObject(auth, "Pi auth");
+    assertPlainObject(models, "Pi models");
+    assertPlainObject(settings, "Pi settings");
+    const nextModels = buildPiModelsConfig(models, intent);
+    const currentModelsContent = transaction.readText(paths.piModelsPath, "{}\n");
+    const nextAuth = buildPiAuthConfig(auth, intent.apiKey);
+    const nextSettings = buildPiSettingsConfig(settings, intent.defaultModel);
+    const nextModelsContent = updatePiModelsContent(
+      currentModelsContent,
+      nextModels.providers[piProviderId]
+    );
+    const validatedModels = JSON.parse(stripJsonComments(nextModelsContent));
+    assertPlainObject(validatedModels, "Pi models");
+
+    await transaction.writeJson(paths.piAuthPath, nextAuth, {
+      ...(operations.writeAuth ? { writer: operations.writeAuth } : {})
+    });
+    await transaction.writeText(
+      paths.piModelsPath,
+      nextModelsContent,
+      { ...(operations.writeModels ? { writer: operations.writeModels } : {}) }
+    );
+    await transaction.writeJson(paths.piSettingsPath, nextSettings, {
+      ...(operations.writeSettings ? { writer: operations.writeSettings } : {})
+    });
   });
+}
 
-  const modelIdsText = await text({
-    message: `${providerLabel} 模型 ID（多个用逗号分隔）`,
-    initialValue: (existing.modelIds.length
-      ? existing.modelIds
-      : existing.defaultModel ? [existing.defaultModel] : []).join(","),
-    validate: (value) => parsePiModelIds(value).length ? undefined : "至少需要一个模型 ID"
-  });
-  assertNotCancelled(modelIdsText);
-  const modelIds = parsePiModelIds(modelIdsText);
+async function configurePiApi(paths, withExtensionsPresent, promptApi, runtime = {}) {
+  if (typeof withExtensionsPresent !== "function") {
+    throw new TypeError("Expected a Pi Extensions deployment function");
+  }
+  return withExtensionsPresent(paths, async (guard) => {
+    await guard();
+    const text = runtime.text ?? p.text;
+    const {
+      assertNotCancelled,
+      passwordOrExisting,
+      selectOrCancel
+    } = promptApi;
+    const { auth, models, settings } = await readExistingPiConfiguration(paths);
+    const existing = resolveExistingPiApiConfig(models, settings, auth);
+    const providerLabel = `Pi ${piProviderId}`;
+
+    const baseUrlInput = await text({
+      message: `${providerLabel} Base URL`,
+      initialValue: existing.baseUrl || undefined,
+      validate: (value) => {
+        try {
+          normalizeOpenAiBaseUrl(value);
+        } catch (error) {
+          return error.message;
+        }
+      }
+    });
+    assertNotCancelled(baseUrlInput);
+    const inferredApi = inferPiApiFromBaseUrl(baseUrlInput);
+    const baseUrl = normalizeOpenAiBaseUrl(baseUrlInput);
+
+    const apiOptions = getPiApiPromptOptions();
+    const initialApi = apiOptions.some((option) => option.value === existing.api)
+      ? existing.api
+      : undefined;
+    const api = inferredApi || await selectOrCancel({
+      message: `${providerLabel} API 类型`,
+      options: apiOptions,
+      ...(initialApi ? { initialValue: initialApi } : {})
+    });
+    const apiKey = await passwordOrExisting({
+      message: `${providerLabel} API Key`,
+      existingValue: existing.apiKey
+    });
 
-  const defaultModel = await text({
-    message: "Pi 默认模型",
-    initialValue: modelIds.includes(existing.defaultModel) ? existing.defaultModel : modelIds[0],
-    validate: (value) => modelIds.includes(String(value || "").trim()) ? undefined : "默认模型必须在模型 ID 列表中"
-  });
-  assertNotCancelled(defaultModel);
+    const modelIdsText = await text({
+      message: `${providerLabel} 模型 ID（多个用逗号分隔）`,
+      initialValue: existing.modelIds.join(",") || undefined,
+      validate: (value) => parsePiModelIds(value).length ? undefined : "至少需要一个模型 ID"
+    });
+    assertNotCancelled(modelIdsText);
+    const modelIds = parsePiModelIds(modelIdsText);
+    const defaultModel = await text({
+      message: "Pi 默认模型",
+      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,
-    modelIds,
-    defaultModel: finalDefaultModel
+    await guard();
+    await persistPiConfiguration(paths, {
+      apiKey,
+      baseUrl,
+      api,
+      modelIds,
+      defaultModel: String(defaultModel).trim()
+    });
   });
-  await ensurePiResourcesLinked(paths);
-  await persistPiConfiguration(paths, configuration);
-
-  log.step(`已更新 ${pathToLabel(paths.piModelsPath, paths.homeDir)} (${providerId}, ${baseUrl})`);
-  log.step(`已更新 ${pathToLabel(paths.piSettingsPath, paths.homeDir)} (默认模型: ${finalDefaultModel})`);
-  log.step(`已更新 ${pathToLabel(paths.piAuthPath, paths.homeDir)} (${maskSecret(finalApiKey)})`);
-  log.step(`已链接 Pi 扩展到 ${pathToLabel(join(paths.piAgentDir, "extensions"), paths.homeDir)}`);
 }
 
 export {
-  assertConfigurablePiProvider,
-  assertSupportedPiVersion,
   buildPiAuthConfig,
-  buildPiConfiguration,
   buildPiModelsConfig,
   buildPiSettingsConfig,
   configurePiApi,
-  detectPiEffectiveModel,
   getPiApiPromptOptions,
-  getPiProcessInvocation,
   inferPiApiFromBaseUrl,
   normalizeOpenAiBaseUrl,
-  parsePiRpcEffectiveModel,
   parsePiModelIds,
   persistPiConfiguration,
   readExistingPiConfiguration,
-  resolveExistingPiApiConfig,
-  resolvePiApiTarget,
-  runPiRpcCommand,
-  updatePiAuthFile
+  resolveExistingPiApiConfig
 };