oh-pi 0.1.78 → 0.1.80

package/dist/index.js

@@ -38,9 +38,9 @@ export async function run() {
  * @returns 生成的配置对象
  */
 async function quickFlow(env) {
-    const providers = await setupProviders(env);
+    const providerSetup = await setupProviders(env);
     return {
-        providers,
+        ...providerSetup,
         theme: "dark",
         keybindings: "default",
         extensions: ["safe-guard", "git-guard", "auto-session-name", "custom-footer", "compact-header", "auto-update"],
@@ -56,8 +56,8 @@ async function quickFlow(env) {
  */
 async function presetFlow(env) {
     const preset = await selectPreset();
-    const providers = await setupProviders(env);
-    return { ...preset, providers };
+    const providerSetup = await setupProviders(env);
+    return { ...preset, ...providerSetup };
 }
 /**
  * 自定义配置流程。用户逐项选择主题、快捷键、扩展、代理等，并可配置高级选项（如自动压缩阈值）。
@@ -65,7 +65,7 @@ async function presetFlow(env) {
  * @returns 生成的配置对象
  */
 async function customFlow(env) {
-    const providers = await setupProviders(env);
+    const providerSetup = await setupProviders(env);
     const theme = await selectTheme();
     const keybindings = await selectKeybindings();
     const extensions = await selectExtensions();
@@ -80,7 +80,7 @@ async function customFlow(env) {
         process.exit(0);
     }
     return {
-        providers,
+        ...providerSetup,
         theme,
         keybindings,
         extensions,

package/dist/locales.js

@@ -20,6 +20,10 @@ export const messages = {
         "mode.customHint": "Pick everything yourself",
         // provider
         "provider.select": "Select API providers",
+        "provider.selectPrimary": "Select your primary API provider",
+        "provider.selectAdditional": "Select an additional provider",
+        "provider.addFallback": "Add a fallback provider? (advanced)",
+        "provider.selectFallback": "Select a fallback provider",
         "provider.custom": "🔧 Custom endpoint",
         "provider.customHint": "Ollama, vLLM, LiteLLM, any OpenAI-compatible",
         "provider.foundEnv": "Found {env} in environment. Use it?",
@@ -46,6 +50,13 @@ export const messages = {
         "provider.modelNamePlaceholder": "llama3.1:8b",
         "provider.modelNameRequired": "Model name required",
         "provider.customConfigured": "{name} configured ({url})",
+        "provider.apiMode": "OpenAI API mode for {label}:",
+        "provider.apiModeAuto": "Auto (Recommended)",
+        "provider.apiModeAutoHint": "Use Responses for reasoning-first models (selected: {model})",
+        "provider.apiModeResponses": "Responses API",
+        "provider.apiModeResponsesHint": "Modern OpenAI API surface",
+        "provider.apiModeCompletions": "Chat Completions API",
+        "provider.apiModeCompletionsHint": "Legacy-compatible endpoint",
         "provider.configureCaps": "Configure model capabilities? (context window, multimodal, reasoning)",
         "provider.contextWindow": "Context window size (tokens):",
         "provider.contextWindowValidation": "Must be a number ≥ 1024",
@@ -54,10 +65,12 @@ export const messages = {
         "provider.multimodal": "Supports image input (multimodal)?",
         "provider.reasoning": "Supports extended thinking (reasoning)?",
         "provider.detected": "Existing providers detected: {list}",
-        "provider.detectedSkip": "⏭  Skip — keep existing",
-        "provider.detectedSkipHint": "Don't change provider config",
-        "provider.detectedAdd": "➕ Add new providers",
-        "provider.detectedAddHint": "Configure additional providers",
+        "provider.detectedKeep": "⏭  Keep existing provider config",
+        "provider.detectedKeepHint": "Do not modify auth/settings/models provider entries",
+        "provider.detectedReplace": "♻️  Replace provider config",
+        "provider.detectedReplaceHint": "Reconfigure primary provider and optional fallbacks",
+        "provider.detectedAdd": "➕ Keep existing and add fallback providers",
+        "provider.detectedAddHint": "Keep current primary provider and append additional providers",
         // preset
         "preset.select": "Choose a preset:",
         "preset.full": "⚫ Full Power",
@@ -97,7 +110,12 @@ export const messages = {
         // confirm
         "confirm.title": "Configuration",
         "confirm.providers": "Providers:",
+        "confirm.providerStrategy": "Provider strategy:",
+        "confirm.providerStrategyKeep": "keep existing",
+        "confirm.providerStrategyAdd": "keep existing and add fallback providers",
+        "confirm.providerStrategyReplace": "replace with new setup",
         "confirm.model": "Model:",
+        "confirm.fallbackProviders": "Fallback providers:",
         "confirm.theme": "Theme:",
         "confirm.keybindings": "Keybindings:",
         "confirm.thinking": "Thinking:",
@@ -151,6 +169,10 @@ export const messages = {
         "mode.custom": "🎛️  自定义",
         "mode.customHint": "逐项自选",
         "provider.select": "选择 API 提供商",
+        "provider.selectPrimary": "选择主 Provider",
+        "provider.selectAdditional": "选择新增 Provider",
+        "provider.addFallback": "是否添加备用 Provider？（高级）",
+        "provider.selectFallback": "选择备用 Provider",
         "provider.custom": "🔧 自定义端点",
         "provider.customHint": "Ollama、vLLM、LiteLLM 等 OpenAI 兼容接口",
         "provider.foundEnv": "在环境变量中找到 {env}，是否使用？",
@@ -177,6 +199,13 @@ export const messages = {
         "provider.modelNamePlaceholder": "llama3.1:8b",
         "provider.modelNameRequired": "模型名称不能为空",
         "provider.customConfigured": "{name} 配置完成 ({url})",
+        "provider.apiMode": "{label} 的 OpenAI API 模式：",
+        "provider.apiModeAuto": "自动（推荐）",
+        "provider.apiModeAutoHint": "推理模型优先用 Responses（当前模型：{model}）",
+        "provider.apiModeResponses": "Responses API",
+        "provider.apiModeResponsesHint": "OpenAI 新版 API",
+        "provider.apiModeCompletions": "Chat Completions API",
+        "provider.apiModeCompletionsHint": "兼容旧接口",
         "provider.configureCaps": "配置模型能力？（上下文窗口、多模态、推理）",
         "provider.contextWindow": "上下文窗口大小（tokens）：",
         "provider.contextWindowValidation": "必须是 ≥ 1024 的数字",
@@ -185,10 +214,12 @@ export const messages = {
         "provider.multimodal": "支持图片输入（多模态）？",
         "provider.reasoning": "支持扩展思考（推理）？",
         "provider.detected": "检测到已有 Provider: {list}",
-        "provider.detectedSkip": "⏭  跳过 — 保留现有配置",
-        "provider.detectedSkipHint": "不修改 Provider 配置",
-        "provider.detectedAdd": "➕ 添加新 Provider",
-        "provider.detectedAddHint": "配置额外的 Provider",
+        "provider.detectedKeep": "⏭  保留现有 Provider 配置",
+        "provider.detectedKeepHint": "不修改 auth/settings/models 中的 Provider 项",
+        "provider.detectedReplace": "♻️  重新配置 Provider",
+        "provider.detectedReplaceHint": "重设主 Provider，并可选配置备用 Provider",
+        "provider.detectedAdd": "➕ 保留现有并新增备用 Provider",
+        "provider.detectedAddHint": "保持当前主 Provider，仅追加新的 Provider",
         "preset.select": "选择预设方案：",
         "preset.full": "⚫ 全功能",
         "preset.fullHint": "所有功能，包括蚁群系统",
@@ -221,7 +252,12 @@ export const messages = {
         "advanced.compactValidation": "必须是 10 到 100 之间的数字",
         "confirm.title": "配置摘要",
         "confirm.providers": "提供商：",
+        "confirm.providerStrategy": "Provider 策略：",
+        "confirm.providerStrategyKeep": "保留现有",
+        "confirm.providerStrategyAdd": "保留现有并新增备用提供商",
+        "confirm.providerStrategyReplace": "替换为新配置",
         "confirm.model": "模型：",
+        "confirm.fallbackProviders": "备用提供商：",
         "confirm.theme": "主题：",
         "confirm.keybindings": "快捷键：",
         "confirm.thinking": "思考：",
@@ -274,6 +310,10 @@ export const messages = {
         "mode.custom": "🎛️  Personnalisé",
         "mode.customHint": "Tout choisir soi-même",
         "provider.select": "Sélectionner les fournisseurs API",
+        "provider.selectPrimary": "Sélectionner le fournisseur API principal",
+        "provider.selectAdditional": "Sélectionner un fournisseur supplémentaire",
+        "provider.addFallback": "Ajouter un fournisseur de secours ? (avancé)",
+        "provider.selectFallback": "Sélectionner un fournisseur de secours",
         "provider.custom": "🔧 Point d'accès personnalisé",
         "provider.customHint": "Ollama, vLLM, LiteLLM, tout compatible OpenAI",
         "provider.foundEnv": "{env} trouvé dans l'environnement. L'utiliser ?",
@@ -300,6 +340,13 @@ export const messages = {
         "provider.modelNamePlaceholder": "llama3.1:8b",
         "provider.modelNameRequired": "Nom du modèle requis",
         "provider.customConfigured": "{name} configuré ({url})",
+        "provider.apiMode": "Mode API OpenAI pour {label} :",
+        "provider.apiModeAuto": "Auto (Recommandé)",
+        "provider.apiModeAutoHint": "Utilise Responses pour les modèles orientés raisonnement (sélectionné : {model})",
+        "provider.apiModeResponses": "API Responses",
+        "provider.apiModeResponsesHint": "Surface API OpenAI moderne",
+        "provider.apiModeCompletions": "API Chat Completions",
+        "provider.apiModeCompletionsHint": "Endpoint compatible historique",
         "provider.configureCaps": "Configurer les capacités du modèle ? (fenêtre de contexte, multimodal, raisonnement)",
         "provider.contextWindow": "Taille de la fenêtre de contexte (tokens) :",
         "provider.contextWindowValidation": "Doit être un nombre ≥ 1024",
@@ -308,10 +355,12 @@ export const messages = {
         "provider.multimodal": "Prend en charge l'entrée d'images (multimodal) ?",
         "provider.reasoning": "Prend en charge la réflexion étendue (raisonnement) ?",
         "provider.detected": "Fournisseurs existants détectés : {list}",
-        "provider.detectedSkip": "⏭  Passer — garder l'existant",
-        "provider.detectedSkipHint": "Ne pas modifier la config des fournisseurs",
-        "provider.detectedAdd": "➕ Ajouter de nouveaux fournisseurs",
-        "provider.detectedAddHint": "Configurer des fournisseurs supplémentaires",
+        "provider.detectedKeep": "⏭  Garder la config fournisseur existante",
+        "provider.detectedKeepHint": "Ne modifie pas les entrées fournisseur de auth/settings/models",
+        "provider.detectedReplace": "♻️  Remplacer la config fournisseur",
+        "provider.detectedReplaceHint": "Reconfigure le fournisseur principal et des secours optionnels",
+        "provider.detectedAdd": "➕ Garder l'existant et ajouter des secours",
+        "provider.detectedAddHint": "Conserve le fournisseur principal actuel et ajoute des fournisseurs supplémentaires",
         "preset.select": "Choisir un préréglage :",
         "preset.full": "⚫ Complet",
         "preset.fullHint": "Toutes les extensions et compétences",
@@ -344,7 +393,12 @@ export const messages = {
         "advanced.compactValidation": "Doit être un nombre entre 10 et 100",
         "confirm.title": "Configuration",
         "confirm.providers": "Fournisseurs :",
+        "confirm.providerStrategy": "Stratégie fournisseur :",
+        "confirm.providerStrategyKeep": "garder l'existant",
+        "confirm.providerStrategyAdd": "garder l'existant et ajouter des fournisseurs de secours",
+        "confirm.providerStrategyReplace": "remplacer par une nouvelle configuration",
         "confirm.model": "Modèle :",
+        "confirm.fallbackProviders": "Fournisseurs de secours :",
         "confirm.theme": "Thème :",
         "confirm.keybindings": "Raccourcis :",
         "confirm.thinking": "Réflexion :",

package/dist/tui/confirm-apply.js

@@ -17,10 +17,32 @@ export function countExisting(env, dir) {
  * @param env - 当前环境信息
  */
 export async function confirmApply(config, env) {
+    const keepProviders = config.providerStrategy === "keep";
+    const addProviders = config.providerStrategy === "add";
+    const providerNames = keepProviders || addProviders
+        ? t("confirm.skipped")
+        : (config.providers.length > 0 ? config.providers.map(p => p.name).join(", ") : t("confirm.none"));
+    const primaryModel = keepProviders
+        ? t("confirm.skipped")
+        : addProviders
+            ? t("confirm.skipped")
+            : (config.providers[0]?.defaultModel || t("confirm.none"));
+    const fallbackProviders = keepProviders
+        ? t("confirm.skipped")
+        : addProviders
+            ? (config.providers.length > 0 ? config.providers.map(p => p.name).join(", ") : t("confirm.none"))
+            : (config.providers.length > 1 ? config.providers.slice(1).map(p => p.name).join(", ") : t("confirm.none"));
+    const providerStrategy = keepProviders
+        ? t("confirm.providerStrategyKeep")
+        : addProviders
+            ? t("confirm.providerStrategyAdd")
+            : t("confirm.providerStrategyReplace");
     // ═══ Summary ═══
     const summary = [
-        `${t("confirm.providers")}  ${chalk.cyan(config.providers.length > 0 ? config.providers.map(p => p.name).join(", ") : t("confirm.skipped"))}`,
-        `${t("confirm.model")}      ${chalk.cyan(config.providers[0]?.defaultModel || t("confirm.skipped"))}`,
+        `${t("confirm.providerStrategy")} ${chalk.cyan(providerStrategy)}`,
+        `${t("confirm.providers")}  ${chalk.cyan(providerNames)}`,
+        `${t("confirm.model")}      ${chalk.cyan(primaryModel)}`,
+        `${t("confirm.fallbackProviders")} ${chalk.cyan(fallbackProviders)}`,
         `${t("confirm.theme")}      ${chalk.cyan(config.theme)}`,
         `${t("confirm.keybindings")}${chalk.cyan(config.keybindings)}`,
         `${t("confirm.thinking")}   ${chalk.cyan(config.thinking)}`,

package/dist/tui/provider-setup.d.ts

@@ -1,10 +1,18 @@
-import type { ProviderConfig } from "../types.js";
+import type { ProviderConfig, ProviderSetupStrategy } from "../types.js";
 import type { EnvInfo } from "../utils/detect.js";
 /** Block internal/private IPs to prevent SSRF */
 export declare function isUnsafeUrl(urlStr: string): boolean;
+type OpenAIApiMode = "auto" | "openai-responses" | "openai-completions";
+export interface ProviderSetupResult {
+    providers: ProviderConfig[];
+    providerStrategy: ProviderSetupStrategy;
+}
+export declare function resolveOpenAIApiMode(mode: OpenAIApiMode, modelId: string): "openai-responses" | "openai-completions";
 /**
- * Interactively configure API providers, detecting existing keys, allowing multi-select, and supporting custom endpoints.
+ * Interactively configure API providers with an explicit strategy.
+ * Default flow: one primary provider. Advanced flow: optional fallback providers.
  * @param env - Current environment info with detected providers
- * @returns Configured provider list
+ * @returns Provider setup result with strategy and selected providers
  */
-export declare function setupProviders(env?: EnvInfo): Promise<ProviderConfig[]>;
+export declare function setupProviders(env?: EnvInfo): Promise<ProviderSetupResult>;
+export {};

package/dist/tui/provider-setup.js

@@ -42,6 +42,14 @@ export function isUnsafeUrl(urlStr) {
         return true;
     }
 }
+export function resolveOpenAIApiMode(mode, modelId) {
+    if (mode !== "auto")
+        return mode;
+    const model = modelId.toLowerCase();
+    if (/^(o\d|gpt-5|gpt-4\.1|gpt-4\.5)/.test(model))
+        return "openai-responses";
+    return "openai-completions";
+}
 /**
  * 动态获取模型列表，依次尝试 Anthropic、Google、OpenAI 兼容 API 风格。
  * @param provider - 提供商名称
@@ -128,19 +136,22 @@ async function fetchModels(provider, baseUrl, apiKey) {
     return { models: [] };
 }
 /**
- * Interactively configure API providers, detecting existing keys, allowing multi-select, and supporting custom endpoints.
+ * Interactively configure API providers with an explicit strategy.
+ * Default flow: one primary provider. Advanced flow: optional fallback providers.
  * @param env - Current environment info with detected providers
- * @returns Configured provider list
+ * @returns Provider setup result with strategy and selected providers
  */
 export async function setupProviders(env) {
     const entries = Object.entries(PROVIDERS);
-    // Detect existing providers — offer skip or add new
+    let providerStrategy = "replace";
+    // Detect existing providers — offer keep / replace / add
     const detected = env?.existingProviders ?? [];
     if (detected.length > 0) {
         const action = await p.select({
             message: t("provider.detected", { list: detected.join(", ") }),
             options: [
-                { value: "skip", label: t("provider.detectedSkip"), hint: t("provider.detectedSkipHint") },
+                { value: "keep", label: t("provider.detectedKeep"), hint: t("provider.detectedKeepHint") },
+                { value: "replace", label: t("provider.detectedReplace"), hint: t("provider.detectedReplaceHint") },
                 { value: "add", label: t("provider.detectedAdd"), hint: t("provider.detectedAddHint") },
             ],
         });
@@ -148,73 +159,165 @@ export async function setupProviders(env) {
             p.cancel(t("cancelled"));
             process.exit(0);
         }
-        if (action === "skip")
-            return [];
+        if (action === "keep") {
+            return { providers: [], providerStrategy: "keep" };
+        }
+        providerStrategy = action;
+    }
+    const selected = new Set(providerStrategy === "add" ? detected : []);
+    const configs = [];
+    if (providerStrategy === "add") {
+        let pickedAny = false;
+        while (true) {
+            const options = [
+                ...entries
+                    .filter(([key]) => !selected.has(key))
+                    .map(([key, info]) => ({ value: key, label: info.label, hint: info.env })),
+                ...(!selected.has("_custom") ? [{ value: "_custom", label: t("provider.custom"), hint: t("provider.customHint") }] : []),
+            ];
+            if (options.length === 0)
+                break;
+            if (pickedAny) {
+                const addMore = await p.confirm({
+                    message: t("provider.addFallback"),
+                    initialValue: false,
+                });
+                if (p.isCancel(addMore)) {
+                    p.cancel(t("cancelled"));
+                    process.exit(0);
+                }
+                if (!addMore)
+                    break;
+            }
+            const next = await p.select({
+                message: pickedAny ? t("provider.selectFallback") : t("provider.selectAdditional"),
+                options,
+            });
+            if (p.isCancel(next)) {
+                p.cancel(t("cancelled"));
+                process.exit(0);
+            }
+            selected.add(next);
+            const added = await setupProviderChoice(next);
+            if (added)
+                configs.push(added);
+            pickedAny = true;
+        }
+        return { providers: configs, providerStrategy: "add" };
     }
-    const selected = await p.multiselect({
-        message: t("provider.select"),
+    const firstChoice = await p.select({
+        message: t("provider.selectPrimary"),
         options: [
             ...entries.map(([key, info]) => ({ value: key, label: info.label, hint: info.env })),
             { value: "_custom", label: t("provider.custom"), hint: t("provider.customHint") },
         ],
-        initialValues: ["anthropic"],
-        required: true,
     });
-    if (p.isCancel(selected)) {
+    if (p.isCancel(firstChoice)) {
         p.cancel(t("cancelled"));
         process.exit(0);
     }
-    const configs = [];
-    for (const name of selected) {
-        if (name === "_custom") {
-            const custom = await setupCustomProvider();
-            if (custom)
-                configs.push(custom);
-            continue;
-        }
-        const info = PROVIDERS[name];
-        const envVal = process.env[info.env];
-        // Ask if user wants a custom endpoint for this provider
-        const useCustomUrl = await p.confirm({
-            message: t("provider.useCustomUrl", { label: info.label }),
+    selected.add(firstChoice);
+    const primary = await setupProviderChoice(firstChoice);
+    if (primary)
+        configs.push(primary);
+    // Advanced: optional fallback providers
+    while (true) {
+        const options = [
+            ...entries
+                .filter(([key]) => !selected.has(key))
+                .map(([key, info]) => ({ value: key, label: info.label, hint: info.env })),
+            ...(!selected.has("_custom") ? [{ value: "_custom", label: t("provider.custom"), hint: t("provider.customHint") }] : []),
+        ];
+        if (options.length === 0)
+            break;
+        const addFallback = await p.confirm({
+            message: t("provider.addFallback"),
             initialValue: false,
         });
-        if (p.isCancel(useCustomUrl)) {
+        if (p.isCancel(addFallback)) {
             p.cancel(t("cancelled"));
             process.exit(0);
         }
-        let baseUrl;
-        if (useCustomUrl) {
-            const url = await p.text({
-                message: t("provider.baseUrl", { label: info.label }),
-                placeholder: "https://proxy.example.com",
-                validate: (v) => (!v || !v.startsWith("http")) ? t("provider.baseUrlValidation") : isUnsafeUrl(v) ? "URL must use HTTPS for remote hosts (private IPs blocked)" : undefined,
-            });
-            if (p.isCancel(url)) {
-                p.cancel(t("cancelled"));
-                process.exit(0);
-            }
-            baseUrl = url;
+        if (!addFallback)
+            break;
+        const next = await p.select({
+            message: t("provider.selectFallback"),
+            options,
+        });
+        if (p.isCancel(next)) {
+            p.cancel(t("cancelled"));
+            process.exit(0);
         }
-        let apiKey;
-        if (envVal && !baseUrl) {
-            const useEnv = await p.confirm({ message: t("provider.foundEnv", { env: chalk.cyan(info.env) }) });
-            if (p.isCancel(useEnv)) {
-                p.cancel(t("cancelled"));
-                process.exit(0);
-            }
-            apiKey = useEnv ? info.env : await promptKey(info.label);
+        selected.add(next);
+        const fallback = await setupProviderChoice(next);
+        if (fallback)
+            configs.push(fallback);
+    }
+    return { providers: configs, providerStrategy: "replace" };
+}
+async function setupProviderChoice(choice) {
+    if (choice === "_custom") {
+        return await setupCustomProvider();
+    }
+    const name = choice;
+    const info = PROVIDERS[name];
+    const envVal = process.env[info.env];
+    const useCustomUrl = await p.confirm({
+        message: t("provider.useCustomUrl", { label: info.label }),
+        initialValue: false,
+    });
+    if (p.isCancel(useCustomUrl)) {
+        p.cancel(t("cancelled"));
+        process.exit(0);
+    }
+    let baseUrl;
+    if (useCustomUrl) {
+        const url = await p.text({
+            message: t("provider.baseUrl", { label: info.label }),
+            placeholder: "https://proxy.example.com",
+            validate: (v) => (!v || !v.startsWith("http")) ? t("provider.baseUrlValidation") : isUnsafeUrl(v) ? "URL must use HTTPS for remote hosts (private IPs blocked)" : undefined,
+        });
+        if (p.isCancel(url)) {
+            p.cancel(t("cancelled"));
+            process.exit(0);
         }
-        else {
-            apiKey = await promptKey(info.label);
+        baseUrl = url;
+    }
+    let apiKey;
+    if (envVal && !baseUrl) {
+        const useEnv = await p.confirm({ message: t("provider.foundEnv", { env: chalk.cyan(info.env) }) });
+        if (p.isCancel(useEnv)) {
+            p.cancel(t("cancelled"));
+            process.exit(0);
         }
-        // Dynamic model fetch — always try
-        const fetchUrl = baseUrl || PROVIDER_API_URLS[name];
-        const { defaultModel, discoveredModels, api } = await selectModelWithMeta(name, info.label, info.models, fetchUrl, apiKey);
-        configs.push({ name, apiKey, defaultModel, baseUrl, api, discoveredModels });
-        p.log.success(t("provider.configured", { label: info.label }));
+        apiKey = useEnv ? info.env : await promptKey(info.label);
+    }
+    else {
+        apiKey = await promptKey(info.label);
+    }
+    const fetchUrl = baseUrl || PROVIDER_API_URLS[name];
+    const { defaultModel, discoveredModels, api } = await selectModelWithMeta(name, info.label, info.models, fetchUrl, apiKey);
+    let finalApi = api;
+    if (name === "openai") {
+        finalApi = await selectOpenAIApiMode(info.label, defaultModel);
+    }
+    p.log.success(t("provider.configured", { label: info.label }));
+    return { name, apiKey, defaultModel, baseUrl, api: finalApi, discoveredModels };
+}
+async function selectOpenAIApiMode(label, defaultModel) {
+    const selected = await p.select({
+        message: t("provider.apiMode", { label }),
+        options: [
+            { value: "auto", label: t("provider.apiModeAuto"), hint: t("provider.apiModeAutoHint", { model: defaultModel }) },
+            { value: "openai-responses", label: t("provider.apiModeResponses"), hint: t("provider.apiModeResponsesHint") },
+            { value: "openai-completions", label: t("provider.apiModeCompletions"), hint: t("provider.apiModeCompletionsHint") },
+        ],
+    });
+    if (p.isCancel(selected)) {
+        p.cancel(t("cancelled"));
+        process.exit(0);
     }
-    return configs;
+    return resolveOpenAIApiMode(selected, defaultModel);
 }
 /**
  * Interactively configure a custom provider (Ollama, vLLM, or other OpenAI-compatible endpoints).

package/dist/tui/provider-setup.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { isUnsafeUrl } from "./provider-setup.js";
+import { isUnsafeUrl, resolveOpenAIApiMode } from "./provider-setup.js";
 describe("isUnsafeUrl", () => {
     it("https remote is safe", () => {
         expect(isUnsafeUrl("https://api.example.com")).toBe(false);
@@ -38,3 +38,17 @@ describe("isUnsafeUrl", () => {
         expect(isUnsafeUrl("")).toBe(true);
     });
 });
+describe("resolveOpenAIApiMode", () => {
+    it("keeps explicit responses mode", () => {
+        expect(resolveOpenAIApiMode("openai-responses", "gpt-4o")).toBe("openai-responses");
+    });
+    it("keeps explicit completions mode", () => {
+        expect(resolveOpenAIApiMode("openai-completions", "o3-mini")).toBe("openai-completions");
+    });
+    it("auto resolves o-series to responses", () => {
+        expect(resolveOpenAIApiMode("auto", "o3-mini")).toBe("openai-responses");
+    });
+    it("auto resolves gpt-4o to completions", () => {
+        expect(resolveOpenAIApiMode("auto", "gpt-4o")).toBe("openai-completions");
+    });
+});

package/dist/types.d.ts

@@ -1,5 +1,6 @@
 /** 支持的语言区域 */
 export type Locale = "en" | "zh" | "fr";
+export type ProviderSetupStrategy = "keep" | "replace" | "add";
 /** 动态发现的模型信息 */
 export interface DiscoveredModel {
     id: string;
@@ -35,6 +36,8 @@ export interface ProviderConfig {
 export interface OhPConfig {
     /** 已配置的提供商列表 */
     providers: ProviderConfig[];
+    /** Provider 配置策略：保留现有、替换，或在现有基础上新增 */
+    providerStrategy?: ProviderSetupStrategy;
     /** 主题名称 */
     theme: string;
     /** 快捷键方案 */

package/dist/utils/writers.js

@@ -12,18 +12,34 @@ If the ant_colony tool is available, automatically use it when the task is compl
 For simple one-file tasks, execute directly without colony overhead.
 After launching ant_colony, use passive mode: wait for COLONY_SIGNAL updates and do not poll bg_colony_status unless the user explicitly asks for a manual snapshot.
 `;
+function readJson(file) {
+    try {
+        return JSON.parse(readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
 /** 步骤 1-2: 生成 auth.json + settings.json */
 export function writeProviderEnv(agentDir, config) {
+    if (config.providerStrategy === "keep")
+        return;
+    const strategy = config.providerStrategy ?? "replace";
+    const authPath = join(agentDir, "auth.json");
+    const settingsPath = join(agentDir, "settings.json");
     // auth.json
     const authProviders = config.providers.filter(p => !p.baseUrl && p.apiKey !== "none");
     if (authProviders.length > 0) {
-        const auth = {};
+        const auth = strategy === "add" ? (readJson(authPath) ?? {}) : {};
         for (const p of authProviders) {
             auth[p.name] = { type: "api_key", key: p.apiKey };
         }
-        writeFileSync(join(agentDir, "auth.json"), JSON.stringify(auth, null, 2), { mode: 0o600 });
+        writeFileSync(authPath, JSON.stringify(auth, null, 2), { mode: 0o600 });
     }
     // settings.json
+    const existingSettings = strategy === "add"
+        ? (readJson(settingsPath) ?? {})
+        : {};
     const primary = config.providers.find(p => p.baseUrl && p.defaultModel) ?? config.providers[0];
     const providerInfo = primary ? PROVIDERS[primary.name] : undefined;
     const primaryModelId = primary?.defaultModel ?? providerInfo?.models[0];
@@ -32,8 +48,14 @@ export function writeProviderEnv(agentDir, config) {
     const reserveTokens = Math.max(16384, Math.round(ctxWindow * 0.15));
     const keepRecentTokens = Math.max(16384, Math.round(ctxWindow * 0.15));
     const primaryModel = primary?.defaultModel ?? providerInfo?.models[0];
+    const defaultProviderModel = strategy === "add"
+        ? ((!existingSettings.defaultProvider && primary)
+            ? { defaultProvider: primary.name, defaultModel: primaryModel }
+            : {})
+        : (primary ? { defaultProvider: primary.name, defaultModel: primaryModel } : {});
     const settings = {
-        ...(primary ? { defaultProvider: primary.name, defaultModel: primaryModel } : {}),
+        ...existingSettings,
+        ...defaultProviderModel,
         defaultThinkingLevel: config.thinking,
         theme: config.theme,
         enableSkillCommands: true,
@@ -41,26 +63,50 @@ export function writeProviderEnv(agentDir, config) {
         retry: { enabled: true, maxRetries: 3 },
         quietStartup: true,
     };
-    if (config.providers.length > 1) {
-        settings.enabledModels = config.providers.flatMap((p) => {
-            if (p.discoveredModels?.length)
-                return p.discoveredModels.map(m => m.id);
-            const info = PROVIDERS[p.name];
-            return info ? info.models : [];
-        });
+    const nextEnabledModels = config.providers.flatMap((p) => {
+        if (p.discoveredModels?.length)
+            return p.discoveredModels.map(m => m.id);
+        const info = PROVIDERS[p.name];
+        return info ? info.models : [];
+    });
+    if (strategy === "add") {
+        const current = Array.isArray(existingSettings.enabledModels)
+            ? existingSettings.enabledModels
+            : [];
+        const merged = [...new Set([...current, ...nextEnabledModels])];
+        if (merged.length > 0)
+            settings.enabledModels = merged;
+    }
+    else if (config.providers.length > 1) {
+        settings.enabledModels = nextEnabledModels;
     }
-    writeFileSync(join(agentDir, "settings.json"), JSON.stringify(settings, null, 2));
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
 }
 /** 步骤 3: 生成 models.json（自定义端点） */
 export function writeModelConfig(agentDir, config) {
-    const customProviders = config.providers.filter(p => p.baseUrl);
-    if (customProviders.length === 0)
+    if (config.providerStrategy === "keep")
         return;
-    const providers = {};
-    for (const cp of customProviders) {
+    const strategy = config.providerStrategy ?? "replace";
+    const modelsPath = join(agentDir, "models.json");
+    // Persist custom endpoints and API mode overrides (e.g. built-in OpenAI responses/completions choice).
+    const modelProviders = config.providers.filter(p => p.baseUrl || (!!p.api && !!PROVIDERS[p.name]));
+    if (modelProviders.length === 0)
+        return;
+    const providers = strategy === "add"
+        ? (readJson(modelsPath)?.providers ?? {})
+        : {};
+    for (const cp of modelProviders) {
         const isBuiltin = !!PROVIDERS[cp.name];
+        if (!cp.baseUrl && isBuiltin && cp.api) {
+            providers[cp.name] = { api: cp.api };
+            continue;
+        }
+        if (!cp.baseUrl)
+            continue;
         if (isBuiltin && !cp.discoveredModels?.length) {
             const entry = { baseUrl: cp.baseUrl };
+            if (cp.api)
+                entry.api = cp.api;
             if (cp.apiKey !== "none")
                 entry.apiKey = cp.apiKey;
             providers[cp.name] = entry;
@@ -93,7 +139,7 @@ export function writeModelConfig(agentDir, config) {
             providers[cp.name] = entry;
         }
     }
-    writeFileSync(join(agentDir, "models.json"), JSON.stringify({ providers }, null, 2));
+    writeFileSync(modelsPath, JSON.stringify({ providers }, null, 2));
 }
 /** 步骤 4: 生成 keybindings.json */
 export function writeKeybindings(agentDir, config) {

package/dist/utils/writers.test.js

@@ -1,8 +1,8 @@
 import { describe, it, expect, afterEach } from "vitest";
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync, existsSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { writeAgents } from "./writers.js";
+import { writeAgents, writeProviderEnv, writeModelConfig } from "./writers.js";
 const tempDirs = [];
 function makeTempDir() {
     const dir = mkdtempSync(join(tmpdir(), "oh-pi-writers-"));
@@ -58,3 +58,144 @@ describe("writeAgents", () => {
         expect(content).toContain("You command an autonomous ant colony");
     });
 });
+describe("provider keep strategy", () => {
+    it("writeProviderEnv does not touch settings/auth when strategy is keep", () => {
+        const dir = makeTempDir();
+        const settingsPath = join(dir, "settings.json");
+        const authPath = join(dir, "auth.json");
+        const originalSettings = JSON.stringify({ defaultProvider: "openai", defaultModel: "gpt-4o" }, null, 2);
+        const originalAuth = JSON.stringify({ openai: { type: "api_key", key: "OPENAI_API_KEY" } }, null, 2);
+        writeFileSync(settingsPath, originalSettings);
+        writeFileSync(authPath, originalAuth);
+        writeProviderEnv(dir, makeConfig({
+            providerStrategy: "keep",
+            providers: [],
+        }));
+        expect(readFileSync(settingsPath, "utf8")).toBe(originalSettings);
+        expect(readFileSync(authPath, "utf8")).toBe(originalAuth);
+    });
+    it("writeModelConfig does not touch models.json when strategy is keep", () => {
+        const dir = makeTempDir();
+        const modelsPath = join(dir, "models.json");
+        const originalModels = JSON.stringify({
+            providers: {
+                openai: { baseUrl: "https://api.openai.com", api: "openai-responses" },
+            },
+        }, null, 2);
+        writeFileSync(modelsPath, originalModels);
+        writeModelConfig(dir, makeConfig({
+            providerStrategy: "keep",
+            providers: [],
+        }));
+        expect(readFileSync(modelsPath, "utf8")).toBe(originalModels);
+    });
+    it("writeModelConfig creates custom provider entries when replacing", () => {
+        const dir = makeTempDir();
+        writeModelConfig(dir, makeConfig({
+            providerStrategy: "replace",
+            providers: [{
+                    name: "custom-openai",
+                    apiKey: "OPENAI_API_KEY",
+                    baseUrl: "https://api.openai.com",
+                    defaultModel: "gpt-4o",
+                    api: "openai-responses",
+                }],
+        }));
+        const modelsPath = join(dir, "models.json");
+        expect(existsSync(modelsPath)).toBe(true);
+        const text = readFileSync(modelsPath, "utf8");
+        expect(text).toContain("\"custom-openai\"");
+        expect(text).toContain("\"openai-responses\"");
+    });
+    it("writeModelConfig persists API mode for builtin OpenAI without custom baseUrl", () => {
+        const dir = makeTempDir();
+        writeModelConfig(dir, makeConfig({
+            providerStrategy: "replace",
+            providers: [{
+                    name: "openai",
+                    apiKey: "OPENAI_API_KEY",
+                    defaultModel: "gpt-5",
+                    api: "openai-responses",
+                }],
+        }));
+        const modelsPath = join(dir, "models.json");
+        expect(existsSync(modelsPath)).toBe(true);
+        const models = JSON.parse(readFileSync(modelsPath, "utf8"));
+        expect(models.providers.openai.api).toBe("openai-responses");
+        expect(models.providers.openai.baseUrl).toBeUndefined();
+    });
+    it("writeModelConfig keeps API mode when overriding builtin baseUrl without discovered models", () => {
+        const dir = makeTempDir();
+        writeModelConfig(dir, makeConfig({
+            providerStrategy: "replace",
+            providers: [{
+                    name: "openai",
+                    apiKey: "OPENAI_API_KEY",
+                    baseUrl: "https://api.openai.com/v1",
+                    defaultModel: "gpt-4o",
+                    api: "openai-responses",
+                }],
+        }));
+        const modelsPath = join(dir, "models.json");
+        expect(existsSync(modelsPath)).toBe(true);
+        const models = JSON.parse(readFileSync(modelsPath, "utf8"));
+        expect(models.providers.openai.baseUrl).toBe("https://api.openai.com/v1");
+        expect(models.providers.openai.api).toBe("openai-responses");
+    });
+    it("writeProviderEnv merges auth/settings when strategy is add", () => {
+        const dir = makeTempDir();
+        const settingsPath = join(dir, "settings.json");
+        const authPath = join(dir, "auth.json");
+        writeFileSync(settingsPath, JSON.stringify({
+            defaultProvider: "anthropic",
+            defaultModel: "claude-sonnet-4-20250514",
+            enabledModels: ["claude-sonnet-4-20250514"],
+            theme: "dark",
+        }, null, 2));
+        writeFileSync(authPath, JSON.stringify({
+            anthropic: { type: "api_key", key: "ANTHROPIC_API_KEY" },
+        }, null, 2));
+        writeProviderEnv(dir, makeConfig({
+            providerStrategy: "add",
+            theme: "light",
+            providers: [{
+                    name: "openai",
+                    apiKey: "OPENAI_API_KEY",
+                    defaultModel: "gpt-4o",
+                    discoveredModels: [{ id: "gpt-4o", reasoning: false, input: ["text", "image"], contextWindow: 128000, maxTokens: 16384 }],
+                }],
+        }));
+        const settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+        const auth = JSON.parse(readFileSync(authPath, "utf8"));
+        expect(settings.defaultProvider).toBe("anthropic");
+        expect(settings.defaultModel).toBe("claude-sonnet-4-20250514");
+        expect(settings.theme).toBe("light");
+        expect(settings.enabledModels).toContain("claude-sonnet-4-20250514");
+        expect(settings.enabledModels).toContain("gpt-4o");
+        expect(auth.anthropic).toBeTruthy();
+        expect(auth.openai).toEqual({ type: "api_key", key: "OPENAI_API_KEY" });
+    });
+    it("writeModelConfig merges custom providers when strategy is add", () => {
+        const dir = makeTempDir();
+        const modelsPath = join(dir, "models.json");
+        writeFileSync(modelsPath, JSON.stringify({
+            providers: {
+                existing: { baseUrl: "https://example.com/v1", api: "openai-completions" },
+            },
+        }, null, 2));
+        writeModelConfig(dir, makeConfig({
+            providerStrategy: "add",
+            providers: [{
+                    name: "custom-openai",
+                    apiKey: "OPENAI_API_KEY",
+                    baseUrl: "https://api.openai.com",
+                    defaultModel: "gpt-4o",
+                    api: "openai-responses",
+                }],
+        }));
+        const models = JSON.parse(readFileSync(modelsPath, "utf8"));
+        expect(models.providers.existing).toBeTruthy();
+        expect(models.providers["custom-openai"]).toBeTruthy();
+        expect(JSON.stringify(models.providers["custom-openai"])).toContain("openai-responses");
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-pi",
-  "version": "0.1.78",
+  "version": "0.1.80",
   "description": "One-click setup for pi-coding-agent. Like oh-my-zsh for pi.",
   "type": "module",
   "bin": {