oh-pi 0.1.80 → 0.1.82

package/dist/index.js

@@ -1,4 +1,4 @@
-import * as p from "@clack/prompts";
+import chalk from "chalk";
 import { selectLanguage, getLocale } from "./i18n.js";
 import { t } from "./i18n.js";
 import { welcome } from "./tui/welcome.js";
@@ -9,8 +9,10 @@ import { selectTheme } from "./tui/theme-select.js";
 import { selectKeybindings } from "./tui/keybinding-select.js";
 import { selectExtensions } from "./tui/extension-select.js";
 import { selectAgents } from "./tui/agents-select.js";
+import { runHorizontalTabs } from "./tui/horizontal-tabs.js";
 import { confirmApply } from "./tui/confirm-apply.js";
 import { detectEnv } from "./utils/detect.js";
+import { EXTENSIONS } from "./registry.js";
 /**
  * 主入口函数。检测环境、选择语言、展示欢迎界面，根据用户选择的模式执行对应配置流程，最终确认并应用配置。
  */
@@ -56,8 +58,7 @@ async function quickFlow(env) {
  */
 async function presetFlow(env) {
     const preset = await selectPreset();
-    const providerSetup = await setupProviders(env);
-    return { ...preset, ...providerSetup };
+    return runTabbedFlow(env, preset);
 }
 /**
  * 自定义配置流程。用户逐项选择主题、快捷键、扩展、代理等，并可配置高级选项（如自动压缩阈值）。
@@ -65,27 +66,122 @@ async function presetFlow(env) {
  * @returns 生成的配置对象
  */
 async function customFlow(env) {
-    const providerSetup = await setupProviders(env);
-    const theme = await selectTheme();
-    const keybindings = await selectKeybindings();
-    const extensions = await selectExtensions();
-    const agents = await selectAgents();
-    // Advanced: auto-compaction is now automatic based on model context window
-    const wantAdvanced = await p.confirm({
-        message: t("advanced.configure"),
-        initialValue: false,
+    const defaultExtensions = EXTENSIONS.filter(e => e.default).map(e => e.name);
+    return runTabbedFlow(env, {
+        theme: "dark",
+        keybindings: "default",
+        extensions: defaultExtensions,
+        prompts: ["review", "fix", "explain", "commit", "test", "refactor", "optimize", "security", "document", "pr"],
+        agents: "general-developer",
+        thinking: "medium",
     });
-    if (p.isCancel(wantAdvanced)) {
-        p.cancel(t("cancelled"));
-        process.exit(0);
+}
+async function runTabbedFlow(env, initial) {
+    const defaultExtensions = EXTENSIONS.filter(e => e.default).map(e => e.name);
+    let providerSetup = null;
+    let theme = initial.theme;
+    let keybindings = initial.keybindings;
+    let extensions = initial.extensions.length > 0 ? [...initial.extensions] : defaultExtensions;
+    let agents = initial.agents;
+    await runHorizontalTabs({
+        title: t("custom.tabHeader"),
+        canFinish: () => !!providerSetup,
+        finishBlockedMessage: () => t("custom.needProviders"),
+        tabs: [
+            {
+                label: t("custom.tabProviders"),
+                summary: () => summarizeProviders(providerSetup),
+                details: () => providerDetails(providerSetup),
+                edit: async () => {
+                    providerSetup = await setupProviders(env);
+                },
+            },
+            {
+                label: t("custom.tabAppearance"),
+                summary: () => `${t("confirm.theme")} ${theme} · ${t("confirm.keybindings")} ${keybindings}`,
+                details: () => [
+                    `${chalk.dim(t("confirm.theme"))} ${chalk.cyan(theme)}`,
+                    `${chalk.dim(t("confirm.keybindings"))} ${chalk.cyan(keybindings)}`,
+                ],
+                edit: async () => {
+                    theme = await selectTheme();
+                    keybindings = await selectKeybindings();
+                },
+            },
+            {
+                label: t("custom.tabFeatures"),
+                summary: () => t("custom.tabFeaturesHint", { count: extensions.length }),
+                details: () => [
+                    chalk.dim(t("confirm.extensions")),
+                    extensions.length > 0 ? `  ${extensions.join(", ")}` : `  ${t("confirm.none")}`,
+                ],
+                edit: async () => {
+                    extensions = await selectExtensions();
+                },
+            },
+            {
+                label: t("custom.tabAgents"),
+                summary: () => `${t("confirm.agents")} ${agents}`,
+                details: () => [
+                    `${chalk.dim(t("confirm.agents"))} ${chalk.cyan(agents)}`,
+                    `${chalk.dim(t("confirm.thinking"))} ${chalk.cyan(initial.thinking)}`,
+                ],
+                edit: async () => {
+                    agents = await selectAgents();
+                },
+            },
+            {
+                label: t("custom.tabFinish"),
+                summary: () => t("custom.tabFinishHint"),
+                details: () => [
+                    chalk.dim(t("custom.tabFinishHelp")),
+                ],
+                edit: async () => {
+                    // Finish tab is read-only; use key F to complete.
+                },
+            },
+        ],
+    });
+    if (!providerSetup) {
+        throw new Error("Provider setup is required before finishing tabbed flow");
     }
+    const finalProviderSetup = providerSetup;
     return {
-        ...providerSetup,
+        providers: finalProviderSetup.providers,
+        providerStrategy: finalProviderSetup.providerStrategy,
         theme,
         keybindings,
         extensions,
-        prompts: ["review", "fix", "explain", "commit", "test", "refactor", "optimize", "security", "document", "pr"],
+        prompts: initial.prompts,
         agents,
-        thinking: "medium",
+        thinking: initial.thinking,
     };
 }
+function summarizeProviders(setup) {
+    if (!setup)
+        return t("custom.providersUnset");
+    if (setup.providerStrategy === "keep")
+        return t("confirm.providerStrategyKeep");
+    if (setup.providerStrategy === "add") {
+        return setup.providers.length > 0
+            ? t("custom.providersAdd", { list: setup.providers.map(p => p.name).join(", ") })
+            : t("confirm.providerStrategyAdd");
+    }
+    if (setup.providers.length === 0)
+        return t("confirm.providerStrategyReplace");
+    return t("custom.providersReplace", { list: setup.providers.map(p => p.name).join(", ") });
+}
+function providerDetails(setup) {
+    if (!setup)
+        return [chalk.dim(t("custom.needProviders"))];
+    if (setup.providerStrategy === "keep")
+        return [chalk.dim(t("confirm.providerStrategyKeep"))];
+    if (setup.providers.length === 0)
+        return [chalk.dim(t("confirm.none"))];
+    const primary = setup.providers[0];
+    return [
+        `${chalk.dim(t("confirm.providerStrategy"))} ${chalk.cyan(setup.providerStrategy)}`,
+        `${chalk.dim(t("confirm.providers"))} ${chalk.cyan(setup.providers.map(p => p.name).join(", "))}`,
+        `${chalk.dim(t("confirm.model"))} ${chalk.cyan(primary?.defaultModel ?? t("confirm.none"))}`,
+    ];
+}

package/dist/locales.js

@@ -18,6 +18,21 @@ export const messages = {
         "mode.presetHint": "Choose a pre-made configuration",
         "mode.custom": "🎛️  Custom",
         "mode.customHint": "Pick everything yourself",
+        "custom.tabHeader": "Custom Setup Tabs",
+        "custom.tabPrompt": "Select a tab to configure",
+        "custom.tabProviders": "Providers",
+        "custom.tabAppearance": "Appearance",
+        "custom.tabFeatures": "Features",
+        "custom.tabFeaturesHint": "{count} extensions enabled",
+        "custom.tabAgents": "Agent Profile",
+        "custom.tabFinish": "Finish",
+        "custom.tabFinishHint": "Review in next step and apply",
+        "custom.tabFinishHelp": "Press F to finish. Press Enter on other tabs to edit.",
+        "custom.tabControls": "Controls: ←/→ switch tabs · Enter edit tab · 1-5 jump · F finish · Ctrl+C cancel",
+        "custom.needProviders": "Please configure Providers first.",
+        "custom.providersUnset": "Providers: not configured",
+        "custom.providersAdd": "Add fallback providers: {list}",
+        "custom.providersReplace": "Replace providers with: {list}",
         // provider
         "provider.select": "Select API providers",
         "provider.selectPrimary": "Select your primary API provider",
@@ -28,16 +43,16 @@ export const messages = {
         "provider.customHint": "Ollama, vLLM, LiteLLM, any OpenAI-compatible",
         "provider.foundEnv": "Found {env} in environment. Use it?",
         "provider.customEndpoint": "Custom endpoint for {label}? (proxy, Azure, etc.)",
-        "provider.baseUrl": "Base URL for {label}:",
+        "provider.baseUrl": "Base URL for {label} (usually without /v1):",
         "provider.useCustomUrl": "Use a custom endpoint for {label}? (proxy, self-hosted, etc.)",
-        "provider.baseUrlPlaceholder": "https://your-proxy.example.com",
-        "provider.baseUrlValidation": "Must be a valid URL",
+        "provider.baseUrlPlaceholder": "https://api.openai.com or https://your-proxy.example.com",
+        "provider.baseUrlValidation": "Must be a valid URL (tip: usually omit /v1)",
         "provider.configured": "{label} configured",
         "provider.name": "Provider name:",
         "provider.namePlaceholder": "ollama",
         "provider.nameRequired": "Name required",
-        "provider.baseUrlCustom": "Base URL:",
-        "provider.baseUrlCustomPlaceholder": "http://localhost:11434",
+        "provider.baseUrlCustom": "Base URL (usually without /v1):",
+        "provider.baseUrlCustomPlaceholder": "http://localhost:11434 (add /v1 only if your gateway requires it)",
         "provider.needsKey": "Requires API key?",
         "provider.apiKey": "API key for {label}:",
         "provider.apiKeyRequired": "API key cannot be empty",
@@ -57,6 +72,8 @@ export const messages = {
         "provider.apiModeResponsesHint": "Modern OpenAI API surface",
         "provider.apiModeCompletions": "Chat Completions API",
         "provider.apiModeCompletionsHint": "Legacy-compatible endpoint",
+        "provider.apiModeNext": "Next Step",
+        "provider.apiModeIntro": "After selecting a model, choose API mode: Responses or Chat Completions.",
         "provider.configureCaps": "Configure model capabilities? (context window, multimodal, reasoning)",
         "provider.contextWindow": "Context window size (tokens):",
         "provider.contextWindowValidation": "Must be a number ≥ 1024",
@@ -168,6 +185,21 @@ export const messages = {
         "mode.presetHint": "选择预制配置",
         "mode.custom": "🎛️  自定义",
         "mode.customHint": "逐项自选",
+        "custom.tabHeader": "自定义配置 Tabs",
+        "custom.tabPrompt": "选择一个页面进行配置",
+        "custom.tabProviders": "Providers",
+        "custom.tabAppearance": "外观",
+        "custom.tabFeatures": "功能",
+        "custom.tabFeaturesHint": "已启用 {count} 个扩展",
+        "custom.tabAgents": "Agent 模板",
+        "custom.tabFinish": "完成",
+        "custom.tabFinishHint": "下一步可预览并应用",
+        "custom.tabFinishHelp": "按 F 完成；在其他页面按 Enter 进入编辑。",
+        "custom.tabControls": "操作：←/→ 切换标签 · Enter 编辑当前标签 · 1-5 快速跳转 · F 完成 · Ctrl+C 取消",
+        "custom.needProviders": "请先配置 Providers。",
+        "custom.providersUnset": "Providers：未配置",
+        "custom.providersAdd": "新增备用 Providers：{list}",
+        "custom.providersReplace": "替换为 Providers：{list}",
         "provider.select": "选择 API 提供商",
         "provider.selectPrimary": "选择主 Provider",
         "provider.selectAdditional": "选择新增 Provider",
@@ -177,16 +209,16 @@ export const messages = {
         "provider.customHint": "Ollama、vLLM、LiteLLM 等 OpenAI 兼容接口",
         "provider.foundEnv": "在环境变量中找到 {env}，是否使用？",
         "provider.customEndpoint": "为 {label} 设置自定义端点？（代理、Azure 等）",
-        "provider.baseUrl": "{label} 的 Base URL：",
+        "provider.baseUrl": "{label} 的 Base URL（通常不要带 /v1）：",
         "provider.useCustomUrl": "是否使用自定义端点？（代理、自托管等）",
-        "provider.baseUrlPlaceholder": "https://your-proxy.example.com",
-        "provider.baseUrlValidation": "必须是有效的 URL",
+        "provider.baseUrlPlaceholder": "https://api.openai.com 或 https://your-proxy.example.com",
+        "provider.baseUrlValidation": "必须是有效 URL（通常不需要 /v1）",
         "provider.configured": "{label} 配置完成",
         "provider.name": "提供商名称：",
         "provider.namePlaceholder": "ollama",
         "provider.nameRequired": "名称不能为空",
-        "provider.baseUrlCustom": "Base URL：",
-        "provider.baseUrlCustomPlaceholder": "http://localhost:11434",
+        "provider.baseUrlCustom": "Base URL（通常不要带 /v1）：",
+        "provider.baseUrlCustomPlaceholder": "http://localhost:11434（仅当网关要求时再加 /v1）",
         "provider.needsKey": "需要 API 密钥？",
         "provider.apiKey": "{label} 的 API 密钥：",
         "provider.apiKeyRequired": "API 密钥不能为空",
@@ -206,6 +238,8 @@ export const messages = {
         "provider.apiModeResponsesHint": "OpenAI 新版 API",
         "provider.apiModeCompletions": "Chat Completions API",
         "provider.apiModeCompletionsHint": "兼容旧接口",
+        "provider.apiModeNext": "下一步",
+        "provider.apiModeIntro": "选完模型后，需要再选择 API 模式：Responses 或 Chat Completions。",
         "provider.configureCaps": "配置模型能力？（上下文窗口、多模态、推理）",
         "provider.contextWindow": "上下文窗口大小（tokens）：",
         "provider.contextWindowValidation": "必须是 ≥ 1024 的数字",
@@ -309,6 +343,21 @@ export const messages = {
         "mode.presetHint": "Choisir une configuration prédéfinie",
         "mode.custom": "🎛️  Personnalisé",
         "mode.customHint": "Tout choisir soi-même",
+        "custom.tabHeader": "Onglets de configuration personnalisée",
+        "custom.tabPrompt": "Choisissez un onglet à configurer",
+        "custom.tabProviders": "Fournisseurs",
+        "custom.tabAppearance": "Apparence",
+        "custom.tabFeatures": "Fonctionnalités",
+        "custom.tabFeaturesHint": "{count} extensions activées",
+        "custom.tabAgents": "Profil Agent",
+        "custom.tabFinish": "Terminer",
+        "custom.tabFinishHint": "Prévisualiser puis appliquer à l'étape suivante",
+        "custom.tabFinishHelp": "Appuyez sur F pour terminer ; appuyez sur Entrée sur les autres onglets pour éditer.",
+        "custom.tabControls": "Contrôles : ←/→ changer d'onglet · Entrée éditer · 1-5 accès rapide · F terminer · Ctrl+C annuler",
+        "custom.needProviders": "Veuillez d'abord configurer les fournisseurs.",
+        "custom.providersUnset": "Fournisseurs : non configurés",
+        "custom.providersAdd": "Ajouter des fournisseurs de secours : {list}",
+        "custom.providersReplace": "Remplacer par : {list}",
         "provider.select": "Sélectionner les fournisseurs API",
         "provider.selectPrimary": "Sélectionner le fournisseur API principal",
         "provider.selectAdditional": "Sélectionner un fournisseur supplémentaire",
@@ -318,16 +367,16 @@ export const messages = {
         "provider.customHint": "Ollama, vLLM, LiteLLM, tout compatible OpenAI",
         "provider.foundEnv": "{env} trouvé dans l'environnement. L'utiliser ?",
         "provider.customEndpoint": "Point d'accès personnalisé pour {label} ? (proxy, Azure, etc.)",
-        "provider.baseUrl": "URL de base pour {label} :",
+        "provider.baseUrl": "URL de base pour {label} (généralement sans /v1) :",
         "provider.useCustomUrl": "Utiliser un endpoint personnalisé pour {label} ? (proxy, auto-hébergé, etc.)",
-        "provider.baseUrlPlaceholder": "https://your-proxy.example.com",
-        "provider.baseUrlValidation": "Doit être une URL valide",
+        "provider.baseUrlPlaceholder": "https://api.openai.com ou https://your-proxy.example.com",
+        "provider.baseUrlValidation": "Doit être une URL valide (astuce : sans /v1 dans la plupart des cas)",
         "provider.configured": "{label} configuré",
         "provider.name": "Nom du fournisseur :",
         "provider.namePlaceholder": "ollama",
         "provider.nameRequired": "Nom requis",
-        "provider.baseUrlCustom": "URL de base :",
-        "provider.baseUrlCustomPlaceholder": "http://localhost:11434",
+        "provider.baseUrlCustom": "URL de base (généralement sans /v1) :",
+        "provider.baseUrlCustomPlaceholder": "http://localhost:11434 (ajoutez /v1 seulement si votre passerelle l'exige)",
         "provider.needsKey": "Nécessite une clé API ?",
         "provider.apiKey": "Clé API pour {label} :",
         "provider.apiKeyRequired": "La clé API ne peut pas être vide",
@@ -347,6 +396,8 @@ export const messages = {
         "provider.apiModeResponsesHint": "Surface API OpenAI moderne",
         "provider.apiModeCompletions": "API Chat Completions",
         "provider.apiModeCompletionsHint": "Endpoint compatible historique",
+        "provider.apiModeNext": "Étape suivante",
+        "provider.apiModeIntro": "Après le choix du modèle, choisissez le mode API : Responses ou Chat Completions.",
         "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",

package/dist/tui/horizontal-tabs.d.ts

@@ -0,0 +1,14 @@
+export interface HorizontalTabItem {
+    label: string;
+    summary: () => string;
+    details?: () => string[];
+    edit: () => Promise<void>;
+}
+interface HorizontalTabsOptions {
+    title: string;
+    tabs: HorizontalTabItem[];
+    canFinish: () => boolean;
+    finishBlockedMessage?: () => string;
+}
+export declare function runHorizontalTabs(opts: HorizontalTabsOptions): Promise<void>;
+export {};

package/dist/tui/horizontal-tabs.js

@@ -0,0 +1,106 @@
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { emitKeypressEvents } from "node:readline";
+import { t } from "../i18n.js";
+function clearScreen() {
+    process.stdout.write("\x1b[2J\x1b[H");
+}
+function waitForAction(tabCount) {
+    return new Promise((resolve) => {
+        const stdin = process.stdin;
+        const isRawCapable = !!stdin.isTTY && typeof stdin.setRawMode === "function";
+        emitKeypressEvents(stdin);
+        if (isRawCapable)
+            stdin.setRawMode(true);
+        const done = (action) => {
+            stdin.off("keypress", onKeypress);
+            if (isRawCapable)
+                stdin.setRawMode(false);
+            resolve(action);
+        };
+        const onKeypress = (str, key) => {
+            if (key.ctrl && key.name === "c")
+                return done("cancel");
+            if (key.name === "left")
+                return done("left");
+            if (key.name === "right")
+                return done("right");
+            if (key.name === "return" || key.name === "space" || key.name === "e")
+                return done("edit");
+            if (key.name === "f")
+                return done("finish");
+            if (/^[1-9]$/.test(str)) {
+                const idx = Number(str) - 1;
+                if (idx >= 0 && idx < tabCount)
+                    return done({ jump: idx });
+            }
+        };
+        stdin.on("keypress", onKeypress);
+        if (!stdin.isTTY) {
+            done("cancel");
+        }
+    });
+}
+function renderTabs(title, tabs, activeIndex, notice) {
+    clearScreen();
+    console.log(chalk.bold(title));
+    console.log();
+    const tabLine = tabs
+        .map((tab, i) => {
+        const label = `${i + 1}. ${tab.label}`;
+        return i === activeIndex
+            ? chalk.bgCyan.black(` ${label} `)
+            : chalk.gray(` ${label} `);
+    })
+        .join(chalk.gray("  |  "));
+    console.log(tabLine);
+    console.log(chalk.dim(t("custom.tabControls")));
+    console.log();
+    const active = tabs[activeIndex];
+    console.log(chalk.cyan(active.summary()));
+    const details = active.details?.() ?? [];
+    for (const line of details)
+        console.log(line);
+    if (notice) {
+        console.log();
+        console.log(chalk.yellow(notice));
+    }
+}
+export async function runHorizontalTabs(opts) {
+    const tabs = opts.tabs;
+    let activeIndex = 0;
+    let notice;
+    while (true) {
+        renderTabs(opts.title, tabs, activeIndex, notice);
+        notice = undefined;
+        const action = await waitForAction(tabs.length);
+        if (action === "cancel") {
+            p.cancel(t("cancelled"));
+            process.exit(0);
+        }
+        if (action === "left") {
+            activeIndex = (activeIndex - 1 + tabs.length) % tabs.length;
+            continue;
+        }
+        if (action === "right") {
+            activeIndex = (activeIndex + 1) % tabs.length;
+            continue;
+        }
+        if (action === "finish") {
+            if (opts.canFinish()) {
+                clearScreen();
+                return;
+            }
+            notice = opts.finishBlockedMessage?.() ?? t("custom.needProviders");
+            continue;
+        }
+        if (action === "edit") {
+            await tabs[activeIndex].edit();
+            continue;
+        }
+        if (typeof action === "object" && "jump" in action) {
+            activeIndex = action.jump;
+            continue;
+        }
+    }
+}

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

@@ -1,5 +1,10 @@
 import type { ProviderConfig, ProviderSetupStrategy } from "../types.js";
 import type { EnvInfo } from "../utils/detect.js";
+/**
+ * Normalize user-entered base URL for model discovery probes.
+ * Discovery always calls `${base}/v1/models`, so strip trailing `/v1` to avoid `/v1/v1/models`.
+ */
+export declare function normalizeDiscoveryBaseUrl(baseUrl: string): string;
 /** Block internal/private IPs to prevent SSRF */
 export declare function isUnsafeUrl(urlStr: string): boolean;
 type OpenAIApiMode = "auto" | "openai-responses" | "openai-completions";
@@ -8,6 +13,7 @@ export interface ProviderSetupResult {
     providerStrategy: ProviderSetupStrategy;
 }
 export declare function resolveOpenAIApiMode(mode: OpenAIApiMode, modelId: string): "openai-responses" | "openai-completions";
+export declare function isOpenAICompatibleApi(api?: string): boolean;
 /**
  * Interactively configure API providers with an explicit strategy.
  * Default flow: one primary provider. Advanced flow: optional fallback providers.

package/dist/tui/provider-setup.js

@@ -12,6 +12,14 @@ const PROVIDER_API_URLS = {
     xai: "https://api.x.ai",
     mistral: "https://api.mistral.ai",
 };
+/**
+ * Normalize user-entered base URL for model discovery probes.
+ * Discovery always calls `${base}/v1/models`, so strip trailing `/v1` to avoid `/v1/v1/models`.
+ */
+export function normalizeDiscoveryBaseUrl(baseUrl) {
+    const trimmed = baseUrl.trim().replace(/\/+$/, "");
+    return trimmed.replace(/\/v1$/i, "");
+}
 /** Block internal/private IPs to prevent SSRF */
 export function isUnsafeUrl(urlStr) {
     try {
@@ -50,6 +58,9 @@ export function resolveOpenAIApiMode(mode, modelId) {
         return "openai-responses";
     return "openai-completions";
 }
+export function isOpenAICompatibleApi(api) {
+    return !api || api === "openai-completions" || api === "openai-responses";
+}
 /**
  * 动态获取模型列表，依次尝试 Anthropic、Google、OpenAI 兼容 API 风格。
  * @param provider - 提供商名称
@@ -58,7 +69,7 @@ export function resolveOpenAIApiMode(mode, modelId) {
  * @returns 发现的模型列表及检测到的 API 类型
  */
 async function fetchModels(provider, baseUrl, apiKey) {
-    const base = baseUrl.replace(/\/+$/, "");
+    const base = normalizeDiscoveryBaseUrl(baseUrl);
     const resolvedKey = process.env[apiKey] ?? apiKey;
     // Try Anthropic-style first (for known anthropic or any provider)
     try {
@@ -274,7 +285,7 @@ async function setupProviderChoice(choice) {
     if (useCustomUrl) {
         const url = await p.text({
             message: t("provider.baseUrl", { label: info.label }),
-            placeholder: "https://proxy.example.com",
+            placeholder: t("provider.baseUrlPlaceholder"),
             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)) {
@@ -299,7 +310,7 @@ async function setupProviderChoice(choice) {
     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);
+        finalApi = await selectOpenAIApiModeWithHint(info.label, defaultModel);
     }
     p.log.success(t("provider.configured", { label: info.label }));
     return { name, apiKey, defaultModel, baseUrl, api: finalApi, discoveredModels };
@@ -319,6 +330,10 @@ async function selectOpenAIApiMode(label, defaultModel) {
     }
     return resolveOpenAIApiMode(selected, defaultModel);
 }
+async function selectOpenAIApiModeWithHint(label, defaultModel) {
+    p.note(t("provider.apiModeIntro"), t("provider.apiModeNext"));
+    return selectOpenAIApiMode(label, defaultModel);
+}
 /**
  * Interactively configure a custom provider (Ollama, vLLM, or other OpenAI-compatible endpoints).
  * @returns Custom provider config, or null if cancelled
@@ -352,8 +367,11 @@ async function setupCustomProvider() {
         apiKey = await promptKey(name);
     }
     const { defaultModel, discoveredModels, api } = await selectModelWithMeta(name, name, [], baseUrl, apiKey);
+    const finalApi = isOpenAICompatibleApi(api)
+        ? await selectOpenAIApiModeWithHint(name, defaultModel)
+        : api;
     p.log.success(t("provider.customConfigured", { name, url: baseUrl }));
-    return { name, apiKey, defaultModel, baseUrl, api, discoveredModels };
+    return { name, apiKey, defaultModel, baseUrl, api: finalApi, discoveredModels };
 }
 /**
  * Select a default model by dynamically fetching available models, falling back to a static list or manual input.

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

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { isUnsafeUrl, resolveOpenAIApiMode } from "./provider-setup.js";
+import { isOpenAICompatibleApi, isUnsafeUrl, normalizeDiscoveryBaseUrl, resolveOpenAIApiMode } from "./provider-setup.js";
 describe("isUnsafeUrl", () => {
     it("https remote is safe", () => {
         expect(isUnsafeUrl("https://api.example.com")).toBe(false);
@@ -52,3 +52,31 @@ describe("resolveOpenAIApiMode", () => {
         expect(resolveOpenAIApiMode("auto", "gpt-4o")).toBe("openai-completions");
     });
 });
+describe("normalizeDiscoveryBaseUrl", () => {
+    it("keeps regular host URL", () => {
+        expect(normalizeDiscoveryBaseUrl("https://api.openai.com")).toBe("https://api.openai.com");
+    });
+    it("strips trailing slash", () => {
+        expect(normalizeDiscoveryBaseUrl("https://api.openai.com/")).toBe("https://api.openai.com");
+    });
+    it("strips trailing /v1 to avoid /v1/v1 probe", () => {
+        expect(normalizeDiscoveryBaseUrl("https://proxy.example.com/v1")).toBe("https://proxy.example.com");
+    });
+    it("strips trailing /v1/ to avoid /v1/v1 probe", () => {
+        expect(normalizeDiscoveryBaseUrl("http://localhost:11434/v1/")).toBe("http://localhost:11434");
+    });
+});
+describe("isOpenAICompatibleApi", () => {
+    it("treats undefined as openai-compatible", () => {
+        expect(isOpenAICompatibleApi(undefined)).toBe(true);
+    });
+    it("treats openai-completions as openai-compatible", () => {
+        expect(isOpenAICompatibleApi("openai-completions")).toBe(true);
+    });
+    it("treats openai-responses as openai-compatible", () => {
+        expect(isOpenAICompatibleApi("openai-responses")).toBe(true);
+    });
+    it("treats anthropic api as non-openai-compatible", () => {
+        expect(isOpenAICompatibleApi("anthropic-messages")).toBe(false);
+    });
+});

package/dist/utils/install.d.ts

@@ -11,6 +11,10 @@ export declare function syncDir(src: string, dest: string): void;
  * 应用 OhP 配置，生成并写入 ~/.pi/agent/ 下的所有配置文件
  */
 export declare function applyConfig(config: OhPConfig): void;
+/**
+ * Remove all files/dirs managed by oh-pi before strict replace apply.
+ */
+export declare function cleanupManagedConfig(agentDir: string): void;
 /**
  * 全局安装 pi-coding-agent，安装失败时抛出异常
  */

package/dist/utils/install.js

@@ -3,6 +3,17 @@ import { join } from "node:path";
 import { homedir } from "node:os";
 import { execSync } from "node:child_process";
 import { writeProviderEnv, writeModelConfig, writeKeybindings, writeAgents, writeExtensions, writePrompts, writeSkills, writeTheme } from "./writers.js";
+const MANAGED_CONFIG_ENTRIES = [
+    "auth.json",
+    "settings.json",
+    "models.json",
+    "keybindings.json",
+    "AGENTS.md",
+    "extensions",
+    "prompts",
+    "skills",
+    "themes",
+];
 /**
  * 确保目录存在，若不存在则递归创建
  */
@@ -62,6 +73,9 @@ function copyDir(src, dest) {
 export function applyConfig(config) {
     const agentDir = join(homedir(), ".pi", "agent");
     ensureDir(agentDir);
+    if ((config.providerStrategy ?? "replace") === "replace") {
+        cleanupManagedConfig(agentDir);
+    }
     writeProviderEnv(agentDir, config);
     writeModelConfig(agentDir, config);
     writeKeybindings(agentDir, config);
@@ -71,6 +85,14 @@ export function applyConfig(config) {
     writeSkills(agentDir, config);
     writeTheme(agentDir, config);
 }
+/**
+ * Remove all files/dirs managed by oh-pi before strict replace apply.
+ */
+export function cleanupManagedConfig(agentDir) {
+    for (const entry of MANAGED_CONFIG_ENTRIES) {
+        rmSync(join(agentDir, entry), { recursive: true, force: true });
+    }
+}
 /**
  * 全局安装 pi-coding-agent，安装失败时抛出异常
  */

package/dist/utils/install.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/install.test.js

@@ -0,0 +1,49 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { existsSync, mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { cleanupManagedConfig } from "./install.js";
+const tempDirs = [];
+function makeTempDir() {
+    const dir = mkdtempSync(join(tmpdir(), "oh-pi-install-"));
+    tempDirs.push(dir);
+    return dir;
+}
+afterEach(() => {
+    for (const dir of tempDirs.splice(0)) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe("cleanupManagedConfig", () => {
+    it("removes managed files and directories while preserving unmanaged data", () => {
+        const dir = makeTempDir();
+        writeFileSync(join(dir, "auth.json"), "{}");
+        writeFileSync(join(dir, "settings.json"), "{}");
+        writeFileSync(join(dir, "models.json"), "{}");
+        writeFileSync(join(dir, "keybindings.json"), "{}");
+        writeFileSync(join(dir, "AGENTS.md"), "# test");
+        mkdirSync(join(dir, "extensions"), { recursive: true });
+        writeFileSync(join(dir, "extensions", "x.ts"), "export default {}");
+        mkdirSync(join(dir, "prompts"), { recursive: true });
+        writeFileSync(join(dir, "prompts", "x.md"), "prompt");
+        mkdirSync(join(dir, "skills"), { recursive: true });
+        writeFileSync(join(dir, "skills", "x.md"), "skill");
+        mkdirSync(join(dir, "themes"), { recursive: true });
+        writeFileSync(join(dir, "themes", "x.json"), "{}");
+        mkdirSync(join(dir, "sessions"), { recursive: true });
+        writeFileSync(join(dir, "sessions", "keep.json"), "{}");
+        writeFileSync(join(dir, "pi-crash.log"), "keep");
+        cleanupManagedConfig(dir);
+        expect(existsSync(join(dir, "auth.json"))).toBe(false);
+        expect(existsSync(join(dir, "settings.json"))).toBe(false);
+        expect(existsSync(join(dir, "models.json"))).toBe(false);
+        expect(existsSync(join(dir, "keybindings.json"))).toBe(false);
+        expect(existsSync(join(dir, "AGENTS.md"))).toBe(false);
+        expect(existsSync(join(dir, "extensions"))).toBe(false);
+        expect(existsSync(join(dir, "prompts"))).toBe(false);
+        expect(existsSync(join(dir, "skills"))).toBe(false);
+        expect(existsSync(join(dir, "themes"))).toBe(false);
+        expect(existsSync(join(dir, "sessions", "keep.json"))).toBe(true);
+        expect(existsSync(join(dir, "pi-crash.log"))).toBe(true);
+    });
+});

package/package.json

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