yymaxapi 1.0.80 → 1.0.82

package/bin/yymaxapi.js

@@ -94,7 +94,7 @@ const DEFAULT_CLAUDE_MODELS = [
   },
   {
     "id": "claude-opus-4-6",
-    "name": "Claude Opus 4.6 (待恢复)"
+    "name": "Claude Opus 4.6 (待稳定)"
   }
 ];
 
@@ -228,6 +228,127 @@ const CLAUDE_MODELS = PRESETS.models.claude;
 const CODEX_MODELS = PRESETS.models.codex;
 const API_CONFIG = PRESETS.apiConfig;
 
+function getDefaultClaudeModel() {
+  return CLAUDE_MODELS[0] || { id: 'claude-sonnet-4-6', name: 'Claude Sonnet 4.6' };
+}
+
+function getDefaultCodexModel() {
+  return CODEX_MODELS[0] || { id: 'gpt-5.4', name: 'GPT 5.4' };
+}
+
+function buildProviderModelMap(models) {
+  const mapped = {};
+  for (const model of models || []) {
+    if (!model?.id) continue;
+    mapped[model.id] = { name: model.name || model.id };
+  }
+  return mapped;
+}
+
+function getClaudeSwitchHint() {
+  return CLAUDE_MODELS.map(model => model.name).join(' / ');
+}
+
+function getOpencodeSwitchHint() {
+  return [...CLAUDE_MODELS, ...CODEX_MODELS].map(model => model.name).join(' / ');
+}
+
+async function promptClaudeModelSelection(args = {}, message = '选择 Claude 模型:') {
+  const requested = (args['claude-model'] || args.model || args['model-id'] || '').toString().trim();
+  const fallback = getDefaultClaudeModel();
+  if (requested) {
+    return CLAUDE_MODELS.find(model => model.id === requested) || { id: requested, name: requested };
+  }
+
+  if (CLAUDE_MODELS.length <= 1) {
+    return fallback;
+  }
+
+  const { selected } = await inquirer.prompt([{
+    type: 'list',
+    name: 'selected',
+    message,
+    choices: CLAUDE_MODELS.map(model => ({ name: model.name, value: model.id })),
+    default: fallback.id
+  }]);
+
+  return CLAUDE_MODELS.find(model => model.id === selected) || fallback;
+}
+
+async function promptOpencodeDefaultModelSelection(args = {}, message = '选择 Opencode 默认模型:') {
+  const fallbackClaude = getDefaultClaudeModel();
+  const fallbackCodex = getDefaultCodexModel();
+  const requested = (args['default-model'] || args.model || args['claude-model'] || args['codex-model'] || '').toString().trim();
+
+  if (requested) {
+    const inClaude = CLAUDE_MODELS.find(model => model.id === requested);
+    if (inClaude) {
+      return {
+        type: 'claude',
+        providerKey: 'yunyi-claude',
+        modelId: inClaude.id,
+        modelName: inClaude.name,
+        modelKey: `yunyi-claude/${inClaude.id}`
+      };
+    }
+
+    const inCodex = CODEX_MODELS.find(model => model.id === requested);
+    if (inCodex) {
+      return {
+        type: 'codex',
+        providerKey: 'yunyi-codex',
+        modelId: inCodex.id,
+        modelName: inCodex.name,
+        modelKey: `yunyi-codex/${inCodex.id}`
+      };
+    }
+  }
+
+  const defaultValue = `claude:${fallbackClaude.id}`;
+  const choices = [];
+  if (CLAUDE_MODELS.length > 0) {
+    choices.push(new inquirer.Separator('  -- Claude --'));
+    for (const model of CLAUDE_MODELS) {
+      choices.push({ name: model.name, value: `claude:${model.id}` });
+    }
+  }
+  if (CODEX_MODELS.length > 0) {
+    choices.push(new inquirer.Separator('  -- GPT --'));
+    for (const model of CODEX_MODELS) {
+      choices.push({ name: model.name, value: `codex:${model.id}` });
+    }
+  }
+
+  const { picked } = await inquirer.prompt([{
+    type: 'list',
+    name: 'picked',
+    message,
+    choices,
+    default: defaultValue
+  }]);
+
+  const [pickedType, pickedId] = picked.split(':');
+  if (pickedType === 'codex') {
+    const model = CODEX_MODELS.find(item => item.id === pickedId) || fallbackCodex;
+    return {
+      type: 'codex',
+      providerKey: 'yunyi-codex',
+      modelId: model.id,
+      modelName: model.name,
+      modelKey: `yunyi-codex/${model.id}`
+    };
+  }
+
+  const model = CLAUDE_MODELS.find(item => item.id === pickedId) || fallbackClaude;
+  return {
+    type: 'claude',
+    providerKey: 'yunyi-claude',
+    modelId: model.id,
+    modelName: model.name,
+    modelKey: `yunyi-claude/${model.id}`
+  };
+}
+
 // 备份文件名（兼容旧版单文件备份）
 const BACKUP_FILENAME = 'openclaw-default.json.bak';
 const BACKUP_DIR_NAME = 'backups';
@@ -636,6 +757,7 @@ function readConfig(configPath) {
 }
 
 function writeConfig(configPath, config) {
+  sanitizeDefaultModelSelection(config);
   const dir = path.dirname(configPath);
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
@@ -645,7 +767,7 @@ function writeConfig(configPath, config) {
 
 // ============ 多工具配置同步 ============
 
-function writeClaudeCodeSettings(baseUrl, apiKey) {
+function writeClaudeCodeSettings(baseUrl, apiKey, modelId = getDefaultClaudeModel().id) {
   const home = os.homedir();
   // ~/.claude/settings.json
   const claudeDir = path.join(home, '.claude');
@@ -656,9 +778,12 @@ function writeClaudeCodeSettings(baseUrl, apiKey) {
       try { settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8')); } catch { settings = {}; }
     }
     settings.apiBaseUrl = baseUrl.replace(/\/+$/, '');
+    settings.model = modelId;
+    settings.availableModels = CLAUDE_MODELS.map(model => model.id);
     if (!settings.env) settings.env = {};
     settings.env.ANTHROPIC_BASE_URL = baseUrl.replace(/\/+$/, '');
     settings.env.ANTHROPIC_AUTH_TOKEN = apiKey;
+    settings.env.ANTHROPIC_MODEL = modelId;
     if (!fs.existsSync(claudeDir)) fs.mkdirSync(claudeDir, { recursive: true });
     fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
   } catch { /* 非关键，静默失败 */ }
@@ -681,7 +806,7 @@ function writeClaudeCodeSettings(baseUrl, apiKey) {
     try {
       const cleanUrl = baseUrl.replace(/\/+$/, '');
       execSync(
-        `powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('ANTHROPIC_BASE_URL','${cleanUrl}','User'); [Environment]::SetEnvironmentVariable('ANTHROPIC_AUTH_TOKEN','${apiKey}','User'); [Environment]::SetEnvironmentVariable('NODE_TLS_REJECT_UNAUTHORIZED','0','User')"`,
+        `powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('ANTHROPIC_BASE_URL','${cleanUrl}','User'); [Environment]::SetEnvironmentVariable('ANTHROPIC_AUTH_TOKEN','${apiKey}','User'); [Environment]::SetEnvironmentVariable('ANTHROPIC_MODEL','${modelId}','User'); [Environment]::SetEnvironmentVariable('NODE_TLS_REJECT_UNAUTHORIZED','0','User')"`,
         { stdio: 'pipe' }
       );
     } catch { /* best-effort */ }
@@ -693,6 +818,7 @@ function writeClaudeCodeSettings(baseUrl, apiKey) {
       marker,
       `export ANTHROPIC_BASE_URL="${cleanUrl}"`,
       `export ANTHROPIC_AUTH_TOKEN="${apiKey}"`,
+      `export ANTHROPIC_MODEL="${modelId}"`,
       '# 中转站证书校验放宽，避免 unknown certificate verification error',
       'export NODE_TLS_REJECT_UNAUTHORIZED=0',
       markerEnd
@@ -796,7 +922,7 @@ function writeCodexConfig(baseUrl, apiKey, modelId = 'gpt-5.4') {
   } catch { /* 非关键，静默失败 */ }
 }
 
-function writeOpencodeConfig(claudeBaseUrl, codexBaseUrl, apiKey, modelId) {
+function writeOpencodeConfig(claudeBaseUrl, codexBaseUrl, apiKey, defaultModelKey = `yunyi-claude/${getDefaultClaudeModel().id}`) {
   const home = os.homedir();
   const claudeUrl = claudeBaseUrl.replace(/\/+$/, '');
   const codexUrl = (codexBaseUrl || '').replace(/\/+$/, '');
@@ -818,7 +944,7 @@ function writeOpencodeConfig(claudeBaseUrl, codexBaseUrl, apiKey, modelId) {
     existing.provider['yunyi-claude'] = {
       name: '云翼 Claude',
       npm: '@ai-sdk/anthropic',
-      models: { 'claude-sonnet-4-6': { name: 'Claude Sonnet 4.6' } },
+      models: buildProviderModelMap(CLAUDE_MODELS),
       options: { apiKey, baseURL: `${claudeUrl}/v1` }
     };
 
@@ -827,7 +953,7 @@ function writeOpencodeConfig(claudeBaseUrl, codexBaseUrl, apiKey, modelId) {
       existing.provider['yunyi-codex'] = {
         name: '云翼 Codex',
         npm: '@ai-sdk/openai',
-        models: { 'gpt-5.4': { name: 'GPT 5.4' } },
+        models: buildProviderModelMap(CODEX_MODELS),
         options: { apiKey, baseURL: codexUrl }
       };
     }
@@ -839,8 +965,7 @@ function writeOpencodeConfig(claudeBaseUrl, codexBaseUrl, apiKey, modelId) {
     }
 
     // 设置默认模型
-    const rawModelId = modelId || 'claude-sonnet-4-6';
-    existing.model = `yunyi-claude/${rawModelId}`;
+    existing.model = defaultModelKey;
 
     // 从 disabled_providers 中移除我们的 provider
     if (Array.isArray(existing.disabled_providers)) {
@@ -895,14 +1020,14 @@ function syncExternalTools(type, baseUrl, apiKey, extra = {}) {
   const synced = [];
   try {
     if (type === 'claude') {
-      writeClaudeCodeSettings(baseUrl, apiKey);
+      writeClaudeCodeSettings(baseUrl, apiKey, extra.claudeModelId || getDefaultClaudeModel().id);
       synced.push('Claude Code settings');
     } else if (type === 'codex') {
-      writeCodexConfig(baseUrl, apiKey);
+      writeCodexConfig(baseUrl, apiKey, extra.modelId || getDefaultCodexModel().id);
       synced.push('Codex CLI config');
     }
     if (type === 'claude' && extra.codexBaseUrl) {
-      writeOpencodeConfig(baseUrl, extra.codexBaseUrl, apiKey);
+      writeOpencodeConfig(baseUrl, extra.codexBaseUrl, apiKey, extra.opencodeDefaultModelKey || `yunyi-claude/${extra.claudeModelId || getDefaultClaudeModel().id}`);
       synced.push('Opencode config');
     }
   } catch { /* ignore */ }
@@ -1329,6 +1454,413 @@ function coerceModelsRecord(value) {
   return record;
 }
 
+const YUNYI_PROVIDER_ALIASES = {
+  claude: new Set(['claude-yunyi', 'yunyi-claude', 'claude_yunyi']),
+  codex: new Set(['yunyi', 'yunyi-codex', 'codex-yunyi', 'codex_yunyi'])
+};
+
+function looksLikeApiKey(value) {
+  const text = String(value || '').trim();
+  if (!text || text.includes('/') || text.includes(' ')) return false;
+  if (/^(sk-|STP|YK)/i.test(text)) return true;
+  return /^[A-Za-z0-9._-]{16,}$/.test(text);
+}
+
+function isLikelyYunyiBaseUrl(baseUrl) {
+  const urlText = String(baseUrl || '').trim();
+  if (!urlText) return false;
+  try {
+    const hostname = new URL(urlText).hostname.toLowerCase();
+    return hostname.includes('yunyi')
+      || hostname.includes('rdzhvip.com')
+      || hostname === '47.99.42.193'
+      || hostname === '47.97.100.10';
+  } catch {
+    return /yunyi|rdzhvip\.com|47\.99\.42\.193|47\.97\.100\.10/i.test(urlText);
+  }
+}
+
+function isYunyiProviderEntry(name, providerConfig, type) {
+  const cfg = providerConfig || {};
+  const providerName = String(name || '').trim();
+  if (YUNYI_PROVIDER_ALIASES[type]?.has(providerName)) return true;
+
+  const baseUrl = String(cfg.baseUrl || cfg.base_url || '').trim();
+  const api = String(cfg.api || '').trim();
+  if (!isLikelyYunyiBaseUrl(baseUrl)) return false;
+
+  if (type === 'claude') {
+    return api.startsWith('anthropic') || /\/claude(?:\/|$)/.test(baseUrl);
+  }
+  return api.startsWith('openai') || /\/codex(?:\/|$)/.test(baseUrl);
+}
+
+function normalizeProviderModelEntry(model, fallbackContext = {}) {
+  if (!model) return null;
+  if (typeof model === 'string') {
+    return {
+      id: model,
+      name: model,
+      contextWindow: fallbackContext.contextWindow,
+      maxTokens: fallbackContext.maxTokens
+    };
+  }
+  if (typeof model !== 'object') return null;
+
+  const id = String(model.id || model.model || '').trim();
+  if (!id) return null;
+  return {
+    ...model,
+    id,
+    name: model.name || id,
+    contextWindow: model.contextWindow || fallbackContext.contextWindow,
+    maxTokens: model.maxTokens || fallbackContext.maxTokens
+  };
+}
+
+function mergeProviderModels(existingModels = [], incomingModels = [], fallbackContext = {}) {
+  const merged = [];
+  const seen = new Set();
+
+  for (const item of [...existingModels, ...incomingModels]) {
+    const normalized = normalizeProviderModelEntry(item, fallbackContext);
+    if (!normalized || seen.has(normalized.id)) continue;
+    seen.add(normalized.id);
+    merged.push(normalized);
+  }
+
+  return merged;
+}
+
+function renameProviderReferencesInConfig(config, oldName, newName) {
+  if (!oldName || !newName || oldName === newName) return false;
+  let changed = false;
+
+  if (config?.agents?.defaults?.models) {
+    for (const key of Object.keys(config.agents.defaults.models)) {
+      if (!key.startsWith(`${oldName}/`)) continue;
+      const nextKey = `${newName}/${key.slice(oldName.length + 1)}`;
+      if (!config.agents.defaults.models[nextKey]) {
+        const entry = { ...(config.agents.defaults.models[key] || {}) };
+        if (!entry.alias || entry.alias === oldName) entry.alias = newName;
+        config.agents.defaults.models[nextKey] = entry;
+      }
+      delete config.agents.defaults.models[key];
+      changed = true;
+    }
+  }
+
+  if (config?.agents?.defaults?.model) {
+    const modelState = config.agents.defaults.model;
+    if (typeof modelState.primary === 'string' && modelState.primary.startsWith(`${oldName}/`)) {
+      modelState.primary = `${newName}/${modelState.primary.slice(oldName.length + 1)}`;
+      changed = true;
+    }
+    if (Array.isArray(modelState.fallbacks)) {
+      const nextFallbacks = modelState.fallbacks.map(modelKey => (
+        typeof modelKey === 'string' && modelKey.startsWith(`${oldName}/`)
+          ? `${newName}/${modelKey.slice(oldName.length + 1)}`
+          : modelKey
+      ));
+      if (JSON.stringify(nextFallbacks) !== JSON.stringify(modelState.fallbacks)) {
+        modelState.fallbacks = nextFallbacks;
+        changed = true;
+      }
+    }
+  }
+
+  if (config?.auth?.profiles) {
+    for (const key of Object.keys(config.auth.profiles)) {
+      if (!key.startsWith(`${oldName}:`)) continue;
+      const suffix = key.slice(oldName.length + 1);
+      const nextKey = `${newName}:${suffix}`;
+      const profile = { ...(config.auth.profiles[key] || {}) };
+      profile.provider = newName;
+      config.auth.profiles[nextKey] = profile;
+      delete config.auth.profiles[key];
+      changed = true;
+    }
+  }
+
+  return changed;
+}
+
+function suggestConflictProviderName(config, baseName) {
+  const providers = config?.models?.providers || {};
+  let candidate = `${baseName}-legacy`;
+  let index = 2;
+  while (providers[candidate]) {
+    candidate = `${baseName}-legacy-${index}`;
+    index += 1;
+  }
+  return candidate;
+}
+
+function sanitizeProviderConfig(name, providerConfig, typeHint = null) {
+  if (!providerConfig || typeof providerConfig !== 'object') return false;
+  let changed = false;
+
+  if (providerConfig.base_url && !providerConfig.baseUrl) {
+    providerConfig.baseUrl = providerConfig.base_url;
+    delete providerConfig.base_url;
+    changed = true;
+  }
+
+  if (providerConfig.model && !providerConfig.models) {
+    providerConfig.models = [providerConfig.model];
+    delete providerConfig.model;
+    changed = true;
+  }
+
+  const inferredType = typeHint
+    || (String(providerConfig.api || '').startsWith('anthropic') ? 'claude'
+      : String(providerConfig.api || '').startsWith('openai') ? 'codex'
+        : null);
+  const fallbackContext = inferredType === 'claude'
+    ? { contextWindow: API_CONFIG.claude?.contextWindow, maxTokens: API_CONFIG.claude?.maxTokens }
+    : inferredType === 'codex'
+      ? { contextWindow: API_CONFIG.codex?.contextWindow, maxTokens: API_CONFIG.codex?.maxTokens }
+      : {};
+
+  if (providerConfig.models) {
+    const nextModels = mergeProviderModels(providerConfig.models, [], fallbackContext);
+    if (JSON.stringify(nextModels) !== JSON.stringify(providerConfig.models)) {
+      providerConfig.models = nextModels;
+      changed = true;
+    }
+  }
+
+  if (!providerConfig.auth && providerConfig.apiKey) {
+    providerConfig.auth = DEFAULT_AUTH_MODE;
+    changed = true;
+  } else if (typeof providerConfig.auth === 'string') {
+    const authValue = providerConfig.auth.trim();
+    if (authValue === 'api_key') {
+      providerConfig.auth = DEFAULT_AUTH_MODE;
+      changed = true;
+    } else if (!['api-key', 'token', 'none'].includes(authValue)) {
+      if (!providerConfig.apiKey && looksLikeApiKey(authValue)) {
+        providerConfig.apiKey = authValue;
+        providerConfig.auth = DEFAULT_AUTH_MODE;
+        changed = true;
+      } else if (providerConfig.apiKey) {
+        providerConfig.auth = DEFAULT_AUTH_MODE;
+        changed = true;
+      }
+    }
+  }
+
+  if (!providerConfig.headers || Array.isArray(providerConfig.headers) || typeof providerConfig.headers !== 'object') {
+    providerConfig.headers = {};
+    changed = true;
+  }
+
+  if (providerConfig.authHeader === undefined) {
+    if (String(providerConfig.api || '').startsWith('openai')) {
+      providerConfig.authHeader = true;
+      changed = true;
+    } else if (String(providerConfig.api || '').startsWith('anthropic')) {
+      providerConfig.authHeader = false;
+      changed = true;
+    }
+  }
+
+  return changed;
+}
+
+function sanitizeConfigAuthProfiles(config) {
+  if (!config.auth) config.auth = {};
+  if (!config.auth.profiles || typeof config.auth.profiles !== 'object' || Array.isArray(config.auth.profiles)) {
+    config.auth.profiles = {};
+    return true;
+  }
+
+  let changed = false;
+  for (const [key, profile] of Object.entries(config.auth.profiles)) {
+    const provider = (profile && typeof profile === 'object' && profile.provider) || key.split(':')[0];
+    if (!provider) {
+      delete config.auth.profiles[key];
+      changed = true;
+      continue;
+    }
+    const nextProfile = {
+      provider,
+      mode: (profile && typeof profile === 'object' && (profile.mode === 'api-key' ? 'api_key' : profile.mode)) || 'api_key'
+    };
+    if (JSON.stringify(profile) !== JSON.stringify(nextProfile)) {
+      config.auth.profiles[key] = nextProfile;
+      changed = true;
+    }
+  }
+  return changed;
+}
+
+function repairYunyiProviderAliases(config) {
+  if (!config?.models?.providers) return { changed: false, renamedProviders: [] };
+
+  let changed = false;
+  const renamedProviders = [];
+  const providers = config.models.providers;
+
+  for (const type of ['claude', 'codex']) {
+    const canonicalName = API_CONFIG[type]?.providerName;
+    if (!canonicalName) continue;
+
+    const candidateEntries = Object.entries(providers).filter(([name, providerConfig]) => isYunyiProviderEntry(name, providerConfig, type));
+    if (candidateEntries.length === 0) continue;
+
+    if (!providers[canonicalName]) {
+      providers[canonicalName] = {};
+      changed = true;
+    }
+
+    sanitizeProviderConfig(canonicalName, providers[canonicalName], type);
+
+    for (const [name, providerConfig] of candidateEntries) {
+      sanitizeProviderConfig(name, providerConfig, type);
+      if (name === canonicalName) continue;
+
+      const target = providers[canonicalName];
+      if (!target.baseUrl && providerConfig.baseUrl) target.baseUrl = providerConfig.baseUrl;
+      if (!target.api && providerConfig.api) target.api = providerConfig.api;
+      if (!target.apiKey && providerConfig.apiKey) target.apiKey = providerConfig.apiKey;
+      if (!target.auth && providerConfig.auth) target.auth = providerConfig.auth;
+      if (target.authHeader === undefined && providerConfig.authHeader !== undefined) target.authHeader = providerConfig.authHeader;
+      if ((!target.headers || Object.keys(target.headers).length === 0) && providerConfig.headers && typeof providerConfig.headers === 'object') {
+        target.headers = { ...providerConfig.headers };
+      }
+      target.models = mergeProviderModels(target.models, providerConfig.models, type === 'claude'
+        ? { contextWindow: API_CONFIG.claude?.contextWindow, maxTokens: API_CONFIG.claude?.maxTokens }
+        : { contextWindow: API_CONFIG.codex?.contextWindow, maxTokens: API_CONFIG.codex?.maxTokens });
+
+      delete providers[name];
+      renamedProviders.push({ from: name, to: canonicalName });
+      renameProviderReferencesInConfig(config, name, canonicalName);
+      changed = true;
+    }
+
+    sanitizeProviderConfig(canonicalName, providers[canonicalName], type);
+  }
+
+  return { changed, renamedProviders };
+}
+
+function reserveProviderName(config, desiredName, expectedType) {
+  const providers = config?.models?.providers || {};
+  const existing = providers[desiredName];
+  if (!existing) return { changed: false, renamedProviders: [] };
+  if (isYunyiProviderEntry(desiredName, existing, expectedType)) {
+    return { changed: false, renamedProviders: [] };
+  }
+
+  const nextName = suggestConflictProviderName(config, desiredName);
+  providers[nextName] = existing;
+  delete providers[desiredName];
+  sanitizeProviderConfig(nextName, providers[nextName]);
+  renameProviderReferencesInConfig(config, desiredName, nextName);
+  return { changed: true, renamedProviders: [{ from: desiredName, to: nextName }] };
+}
+
+function repairConfigProviders(config, options = {}) {
+  if (!config.models) config.models = {};
+  if (!config.models.providers || typeof config.models.providers !== 'object' || Array.isArray(config.models.providers)) {
+    config.models.providers = {};
+  }
+
+  let changed = false;
+  const renamedProviders = [];
+
+  for (const type of ['claude', 'codex']) {
+    const desiredName = API_CONFIG[type]?.providerName;
+    if (!desiredName) continue;
+    const reserved = reserveProviderName(config, desiredName, type);
+    if (reserved.changed) {
+      changed = true;
+      renamedProviders.push(...reserved.renamedProviders);
+    }
+  }
+
+  const repairedAliases = repairYunyiProviderAliases(config);
+  if (repairedAliases.changed) changed = true;
+
+  for (const [name, providerConfig] of Object.entries(config.models.providers)) {
+    if (sanitizeProviderConfig(name, providerConfig)) {
+      changed = true;
+    }
+  }
+
+  if (sanitizeConfigAuthProfiles(config)) {
+    changed = true;
+  }
+
+  return {
+    changed,
+    renamedProviders: [...renamedProviders, ...repairedAliases.renamedProviders]
+  };
+}
+
+function isValidModelRef(value) {
+  return typeof value === 'string' && value.trim().includes('/');
+}
+
+function collectConfiguredModelKeys(config) {
+  const keys = [];
+
+  const registered = Object.keys(config?.agents?.defaults?.models || {}).filter(isValidModelRef);
+  keys.push(...registered);
+
+  const providers = config?.models?.providers || {};
+  for (const [providerName, providerConfig] of Object.entries(providers)) {
+    for (const model of providerConfig.models || []) {
+      if (!model?.id) continue;
+      const modelKey = `${providerName}/${model.id}`;
+      if (isValidModelRef(modelKey)) keys.push(modelKey);
+    }
+  }
+
+  return [...new Set(keys)];
+}
+
+function inferPrimaryModelKey(config) {
+  return collectConfiguredModelKeys(config)[0] || '';
+}
+
+function normalizeDefaultModelSelection(value, config) {
+  if (typeof value === 'string') {
+    const primary = value.trim();
+    return primary ? { primary, fallbacks: [] } : { fallbacks: [] };
+  }
+
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    let primary = typeof value.primary === 'string' ? value.primary.trim() : '';
+    const fallbacks = Array.isArray(value.fallbacks)
+      ? [...new Set(value.fallbacks.map(item => String(item || '').trim()).filter(isValidModelRef))]
+      : [];
+
+    if (!primary) {
+      primary = inferPrimaryModelKey(config) || fallbacks[0] || '';
+    }
+
+    const normalizedFallbacks = fallbacks.filter(modelKey => modelKey !== primary);
+    const normalized = { fallbacks: normalizedFallbacks };
+    if (primary) normalized.primary = primary;
+    return normalized;
+  }
+
+  const inferred = inferPrimaryModelKey(config);
+  return inferred ? { primary: inferred, fallbacks: [] } : { fallbacks: [] };
+}
+
+function sanitizeDefaultModelSelection(config) {
+  if (!config?.agents?.defaults) return;
+  const normalized = normalizeDefaultModelSelection(config.agents.defaults.model, config);
+  if (normalized.primary) {
+    config.agents.defaults.model = normalized;
+  } else {
+    delete config.agents.defaults.model;
+  }
+}
+
 const OPENCLAW_INVALID_ROOT_KEYS = ['model'];
 
 function sanitizeRootKeys(config) {
@@ -1344,7 +1876,7 @@ function ensureConfigStructure(config) {
   if (!next.models.providers) next.models.providers = {};
   if (!next.agents) next.agents = {};
   if (!next.agents.defaults) next.agents.defaults = {};
-  if (!next.agents.defaults.model) next.agents.defaults.model = {};
+  next.agents.defaults.model = normalizeDefaultModelSelection(next.agents.defaults.model, next);
   if (!next.agents.defaults.models || Array.isArray(next.agents.defaults.models) || typeof next.agents.defaults.models !== 'object') {
     next.agents.defaults.models = coerceModelsRecord(next.agents.defaults.models);
   }
@@ -1515,6 +2047,32 @@ function syncMirroredAuthStores(paths) {
   }
 }
 
+function renameProviderInAuthStore(paths, oldProvider, newProvider) {
+  if (!paths?.authProfiles || !oldProvider || !newProvider || oldProvider === newProvider) return false;
+  const store = readAuthStore(paths.authProfiles);
+  let changed = false;
+
+  for (const key of Object.keys(store.profiles)) {
+    if (!key.startsWith(`${oldProvider}:`)) continue;
+    const suffix = key.slice(oldProvider.length + 1);
+    const nextKey = `${newProvider}:${suffix}`;
+    const profile = { ...(store.profiles[key] || {}) };
+    if (!store.profiles[nextKey]) {
+      profile.provider = newProvider;
+      store.profiles[nextKey] = profile;
+    }
+    delete store.profiles[key];
+    changed = true;
+  }
+
+  if (changed) {
+    writeAuthStore(paths.authProfiles, store);
+    syncMirroredAuthStores(paths);
+  }
+
+  return changed;
+}
+
 function pruneAuthProfilesExceptWithSync(paths, keepProviders = []) {
   const removed = pruneAuthProfilesExcept(paths.authProfiles, keepProviders);
   syncMirroredAuthStores(paths);
@@ -1526,6 +2084,16 @@ function updateAuthProfilesWithSync(paths, providerName, apiKey) {
   syncMirroredAuthStores(paths);
 }
 
+function applyConfigRepairsWithSync(config, paths) {
+  const repairResult = repairConfigProviders(config);
+  if (paths && repairResult.renamedProviders.length > 0) {
+    for (const item of repairResult.renamedProviders) {
+      renameProviderInAuthStore(paths, item.from, item.to);
+    }
+  }
+  return repairResult;
+}
+
 function pruneAuthProfilesByPrefix(authProfilesPath, prefixBase, keepProviders = []) {
   const keepSet = new Set(keepProviders);
   const store = readAuthStore(authProfilesPath);
@@ -1619,6 +2187,20 @@ async function promptApiKey(message, defaultValue) {
   return '';
 }
 
+async function confirmImmediateTest(args = {}, message = '是否立即测试连接？', defaultValue = true) {
+  if (args.test !== undefined) {
+    return !['false', '0', 'no'].includes(String(args.test).toLowerCase());
+  }
+
+  const { shouldTest } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'shouldTest',
+    message,
+    default: defaultValue
+  }]);
+  return shouldTest;
+}
+
 function extendPathEnv(preferredNodePath) {
   const current = process.env.PATH || '';
   const parts = current.split(path.delimiter).filter(Boolean);
@@ -1816,6 +2398,259 @@ function getCliMeta() {
   return { cliBinary, cliName, nodeMajor };
 }
 
+function resolveCommandBinary(names) {
+  const candidates = Array.isArray(names) ? names : [names];
+  const isWin = process.platform === 'win32';
+  const searchDirs = (process.env.PATH || '').split(path.delimiter).concat(EXTRA_BIN_DIRS).filter(Boolean);
+
+  for (const name of candidates) {
+    const variants = isWin ? [`${name}.cmd`, `${name}.exe`, name] : [name];
+    for (const variant of variants) {
+      for (const dir of searchDirs) {
+        const full = path.join(dir, variant);
+        try {
+          if (fs.existsSync(full) && fs.statSync(full).isFile()) {
+            return full;
+          }
+        } catch { }
+      }
+    }
+
+    if (isWin) {
+      const result = safeExec(`where ${name}`);
+      if (result.ok && result.output) {
+        return result.output.split('\n')[0].trim();
+      }
+    } else {
+      for (const sh of ['/bin/zsh', '/bin/bash', '/bin/sh']) {
+        if (!fs.existsSync(sh)) continue;
+        const result = safeExec(`${sh} -lc "command -v ${name}"`);
+        if (result.ok && result.output) {
+          return result.output.split('\n')[0].trim();
+        }
+      }
+    }
+  }
+
+  return null;
+}
+
+function readJsonIfExists(filePath) {
+  if (!filePath || !fs.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function getClaudeCodeSettingsPath() {
+  return path.join(os.homedir(), '.claude', 'settings.json');
+}
+
+function getOpencodeConfigPath() {
+  const home = os.homedir();
+  return process.platform === 'win32'
+    ? path.join(process.env.APPDATA || path.join(home, 'AppData', 'Roaming'), 'opencode', 'opencode.json')
+    : path.join(home, '.config', 'opencode', 'opencode.json');
+}
+
+function getCodexCliPaths() {
+  const codexDir = path.join(os.homedir(), '.codex');
+  return {
+    configPath: path.join(codexDir, 'config.toml'),
+    authPath: path.join(codexDir, 'auth.json')
+  };
+}
+
+function readClaudeCodeCliConfig() {
+  const settingsPath = getClaudeCodeSettingsPath();
+  const settings = readJsonIfExists(settingsPath) || {};
+  return {
+    settingsPath,
+    modelId: settings.model || settings.env?.ANTHROPIC_MODEL || process.env.ANTHROPIC_MODEL || getDefaultClaudeModel().id,
+    baseUrl: settings.env?.ANTHROPIC_BASE_URL || settings.apiBaseUrl || process.env.ANTHROPIC_BASE_URL || '',
+    apiKey: settings.env?.ANTHROPIC_AUTH_TOKEN || process.env.ANTHROPIC_AUTH_TOKEN || '',
+    configured: fs.existsSync(settingsPath)
+  };
+}
+
+function readOpencodeCliConfig() {
+  const configPath = getOpencodeConfigPath();
+  const config = readJsonIfExists(configPath) || {};
+  return {
+    configPath,
+    modelKey: config.model || `yunyi-claude/${getDefaultClaudeModel().id}`,
+    configured: fs.existsSync(configPath),
+    config
+  };
+}
+
+function readCodexCliConfig() {
+  const { configPath, authPath } = getCodexCliPaths();
+  const configRaw = fs.existsSync(configPath) ? fs.readFileSync(configPath, 'utf8') : '';
+  const auth = readJsonIfExists(authPath) || {};
+  const model = (configRaw.match(/^model\s*=\s*"([^"]+)"\s*$/m) || [])[1] || getDefaultCodexModel().id;
+  const provider = (configRaw.match(/^model_provider\s*=\s*"([^"]+)"\s*$/m) || [])[1] || 'yunyi-codex';
+  const providerBlockRegex = new RegExp(`\\[model_providers\\.${escapeRegExp(provider)}\\]([\\s\\S]*?)(?=\\n\\[|$)`, 'm');
+  const providerBlock = (configRaw.match(providerBlockRegex) || [])[1] || '';
+  const baseUrl = (providerBlock.match(/base_url\s*=\s*"([^"]+)"/) || [])[1] || '';
+  const apiKey = (providerBlock.match(/experimental_bearer_token\s*=\s*"([^"]+)"/) || [])[1] || auth.OPENAI_API_KEY || '';
+  return {
+    configPath,
+    authPath,
+    modelId: model,
+    provider,
+    baseUrl,
+    apiKey,
+    configured: fs.existsSync(configPath)
+  };
+}
+
+function cleanCliTestOutput(text) {
+  return String(text || '')
+    .replace(/\u001b\[[0-9;]*m/g, '')
+    .replace(/\(node:\d+\) Warning: Setting the NODE_TLS_REJECT_UNAUTHORIZED[\s\S]*?(?=\n\S|$)/g, '')
+    .replace(/\s+$/g, '')
+    .trim();
+}
+
+function summarizeCliTestOutput(text) {
+  const lines = cleanCliTestOutput(text)
+    .split('\n')
+    .map(line => line.trim())
+    .filter(Boolean)
+    .filter(line => !/^logs?:/i.test(line));
+  if (lines.length === 0) return '';
+  return lines[0].slice(0, 160);
+}
+
+function buildReadableAgentError(text, fallback = '') {
+  const cleaned = cleanCliTestOutput(text);
+  if (!cleaned) return fallback;
+  const lines = cleaned.split('\n').map(line => line.trim()).filter(Boolean);
+  const preferred = lines.find(line => /agent failed before reply|all models failed|auth_permanent|auth issue|unauthorized|forbidden|missing environment variable|provider .* issue|invalid config/i.test(line));
+  return (preferred || lines[0] || fallback).slice(0, 300);
+}
+
+function looksLikeCliTestError(text) {
+  const lower = cleanCliTestOutput(text).toLowerCase();
+  if (!lower) return false;
+  return [
+    'all models failed',
+    'auth_permanent',
+    'auth issue',
+    'unauthorized',
+    'forbidden',
+    'missing environment variable',
+    'gateway agent failed',
+    'error:'
+  ].some(pattern => lower.includes(pattern));
+}
+
+function runCliTestCandidates(name, commands, env) {
+  let lastError = '命令执行失败';
+  for (const command of commands) {
+    const result = safeExec(command, { timeout: 120000, env, maxBuffer: 1024 * 1024 });
+    const combined = cleanCliTestOutput(`${result.output || ''}\n${result.stdout || ''}\n${result.stderr || ''}`);
+    if (result.ok && !looksLikeCliTestError(combined)) {
+      return { name, status: 'success', detail: summarizeCliTestOutput(combined) || '连接成功' };
+    }
+    lastError = summarizeCliTestOutput(combined) || result.error || lastError;
+  }
+  return { name, status: 'failed', detail: lastError };
+}
+
+function testClaudeCodeCliConnection() {
+  const cliBinary = resolveCommandBinary('claude');
+  if (!cliBinary) return { name: 'Claude Code CLI', status: 'skipped', detail: '未安装 claude 命令' };
+
+  const config = readClaudeCodeCliConfig();
+  if (!config.configured) return { name: 'Claude Code CLI', status: 'skipped', detail: '未检测到 ~/.claude/settings.json' };
+  if (!config.baseUrl || !config.apiKey) return { name: 'Claude Code CLI', status: 'failed', detail: 'Claude Code 配置缺少 Base URL 或 API Key' };
+
+  const env = {
+    ...process.env,
+    PATH: extendPathEnv(null),
+    ANTHROPIC_BASE_URL: config.baseUrl,
+    ANTHROPIC_AUTH_TOKEN: config.apiKey,
+    ANTHROPIC_MODEL: config.modelId,
+    NODE_TLS_REJECT_UNAUTHORIZED: '0',
+    NODE_NO_WARNINGS: '1'
+  };
+
+  return runCliTestCandidates('Claude Code CLI', [
+    `${shellQuote(cliBinary)} -p --model ${shellQuote(config.modelId)} --output-format text ${shellQuote('请只回复 OK')}`,
+    `${shellQuote(cliBinary)} -p --model ${shellQuote(config.modelId)} ${shellQuote('请只回复 OK')}`,
+    `${shellQuote(cliBinary)} -p ${shellQuote('请只回复 OK')}`
+  ], env);
+}
+
+function testOpencodeCliConnection() {
+  const cliBinary = resolveCommandBinary('opencode');
+  if (!cliBinary) return { name: 'Opencode CLI', status: 'skipped', detail: '未安装 opencode 命令' };
+
+  const config = readOpencodeCliConfig();
+  if (!config.configured) return { name: 'Opencode CLI', status: 'skipped', detail: '未检测到 opencode 配置文件' };
+
+  const env = {
+    ...process.env,
+    PATH: extendPathEnv(null),
+    NODE_TLS_REJECT_UNAUTHORIZED: '0',
+    NODE_NO_WARNINGS: '1'
+  };
+
+  return runCliTestCandidates('Opencode CLI', [
+    `${shellQuote(cliBinary)} run --model ${shellQuote(config.modelKey)} ${shellQuote('请只回复 OK')}`,
+    `${shellQuote(cliBinary)} run ${shellQuote('请只回复 OK')} --model ${shellQuote(config.modelKey)}`,
+    `${shellQuote(cliBinary)} -m ${shellQuote(config.modelKey)} run ${shellQuote('请只回复 OK')}`
+  ], env);
+}
+
+function testCodexCliConnection() {
+  const cliBinary = resolveCommandBinary('codex');
+  if (!cliBinary) return { name: 'Codex CLI', status: 'skipped', detail: '未安装 codex 命令' };
+
+  const config = readCodexCliConfig();
+  if (!config.configured) return { name: 'Codex CLI', status: 'skipped', detail: '未检测到 ~/.codex/config.toml' };
+  if (!config.apiKey) return { name: 'Codex CLI', status: 'failed', detail: 'Codex CLI 配置缺少 API Key' };
+
+  const env = {
+    ...process.env,
+    PATH: extendPathEnv(null),
+    OPENAI_API_KEY: config.apiKey,
+    NODE_TLS_REJECT_UNAUTHORIZED: '0',
+    NODE_NO_WARNINGS: '1'
+  };
+
+  return runCliTestCandidates('Codex CLI', [
+    `${shellQuote(cliBinary)} exec --skip-git-repo-check ${shellQuote('请只回复 OK')}`,
+    `${shellQuote(cliBinary)} exec ${shellQuote('请只回复 OK')}`
+  ], env);
+}
+
+async function testAdditionalCliConnections(args = {}, options = {}) {
+  if (args['no-app-test'] || args.noAppTest) return;
+
+  const requested = new Set((options.only || ['claude', 'opencode', 'codex']).map(item => String(item)));
+  const results = [];
+  if (requested.has('claude')) results.push(testClaudeCodeCliConnection());
+  if (requested.has('opencode')) results.push(testOpencodeCliConnection());
+  if (requested.has('codex')) results.push(testCodexCliConnection());
+  if (results.length === 0) return;
+
+  console.log(chalk.cyan('\n附加测试: 其他 CLI 连接...'));
+  for (const result of results) {
+    if (result.status === 'success') {
+      console.log(chalk.green(`✅ ${result.name}: ${result.detail}`));
+    } else if (result.status === 'skipped') {
+      console.log(chalk.gray(`○ ${result.name}: ${result.detail}`));
+    } else {
+      console.log(chalk.red(`❌ ${result.name}: ${result.detail}`));
+    }
+  }
+}
+
 function getNodeMajor(versionOutput) {
   const match = String(versionOutput || '').trim().match(/^v?(\d+)/);
   return match ? Number(match[1]) : null;
@@ -1868,11 +2703,20 @@ function findCompatibleNode(minMajor = 22) {
 function autoFixConfig(paths) {
   try {
     const config = readConfig(paths.openclawConfig);
-    if (!config?.models?.providers) return;
+    if (!config) return;
 
     let changed = false;
     const codexProviderName = API_CONFIG.codex?.providerName;
-    const codexProvider = codexProviderName && config.models.providers[codexProviderName];
+    const originalModelJson = JSON.stringify(config.agents?.defaults?.model ?? null);
+    ensureConfigStructure(config);
+    sanitizeDefaultModelSelection(config);
+    const repairResult = applyConfigRepairsWithSync(config, paths);
+    if (repairResult.changed) changed = true;
+    const codexProvider = codexProviderName && config.models.providers?.[codexProviderName];
+    const nextModelJson = JSON.stringify(config.agents?.defaults?.model ?? null);
+    if (originalModelJson !== nextModelJson) {
+      changed = true;
+    }
 
     // 修复: openai-responses → openai-completions（云翼服务器不支持 /v1/responses）
     if (codexProvider && codexProvider.api === 'openai-responses') {
@@ -1888,7 +2732,7 @@ function autoFixConfig(paths) {
 
     if (changed) {
       writeConfig(paths.openclawConfig, config);
-      console.log(chalk.green('✓ 已自动修复配置（openai-responses → openai-completions）'));
+      console.log(chalk.green('✓ 已自动修复配置（模型结构 / API 协议）'));
     }
   } catch { /* ignore */ }
 }
@@ -2391,26 +3235,7 @@ async function quickSetup(paths, args = {}) {
 
   let config = readConfig(paths.openclawConfig) || {};
   config = ensureConfigStructure(config);
-
-  const existingProviders = Object.keys(config.models.providers || {});
-  const toRemove = existingProviders.filter(name => name !== providerName);
-  if (toRemove.length > 0 && !args.force) {
-    const { overwrite } = await inquirer.prompt([{
-      type: 'confirm',
-      name: 'overwrite',
-      message: `检测到已有中转配置: ${existingProviders.join(', ')}，将仅保留 ${providerName}。是否继续？`,
-      default: false
-    }]);
-    if (!overwrite) {
-      console.log(chalk.gray('已取消'));
-      return;
-    }
-  }
-
-  if (toRemove.length > 0) {
-    pruneProvidersExcept(config, [providerName]);
-    pruneAuthProfilesExceptWithSync(paths, [providerName]);
-  }
+  const repairResult = applyConfigRepairsWithSync(config, paths);
 
   config.models.providers[providerName] = {
     baseUrl: normalizedBaseUrl,
@@ -2458,6 +3283,9 @@ async function quickSetup(paths, args = {}) {
   if (setPrimary) {
     console.log(chalk.yellow(`   主模型: ${modelKey}`));
   }
+  if (repairResult.renamedProviders.length > 0) {
+    console.log(chalk.gray(`   已保留并修复冲突 provider: ${repairResult.renamedProviders.map(item => `${item.from}→${item.to}`).join(', ')}`));
+  }
 }
 
 async function presetClaude(paths, args = {}) {
@@ -2504,31 +3332,10 @@ async function presetClaude(paths, args = {}) {
   }
 
   const config = ensureConfigStructure(readConfig(paths.openclawConfig) || {});
+  const repairResult = applyConfigRepairsWithSync(config, paths);
 
   const providerName = (args['provider-name'] || args.provider || providerPrefix).toString().trim() || apiConfig.providerName;
-
-  const existingProviders = Object.keys(config.models.providers || {});
-  const toRemove = existingProviders.filter(name => name !== providerName);
-
-  if (toRemove.length > 0 && !args.force) {
-    const { overwrite } = await inquirer.prompt([{
-      type: 'confirm',
-      name: 'overwrite',
-      message: `检测到已有中转配置: ${existingProviders.join(', ')}，将仅保留 ${providerName}。是否继续？`,
-      default: false
-    }]);
-    if (!overwrite) {
-      console.log(chalk.gray('已取消'));
-      return;
-    }
-  }
-
-  const removedProviders = toRemove.length > 0
-    ? pruneProvidersExcept(config, [providerName])
-    : [];
-  if (removedProviders.length > 0) {
-    pruneAuthProfilesExceptWithSync(paths, [providerName]);
-  }
+  const removedProviders = repairResult.renamedProviders.map(item => item.from);
 
   const baseUrl = buildFullUrl(selectedEndpoint.url, 'claude');
 
@@ -2632,7 +3439,7 @@ async function presetClaude(paths, args = {}) {
   ensureGatewaySettings(config);
   writeConfigWithSync(paths, config);
   updateAuthProfilesWithSync(paths, providerName, apiKey);
-  const extSynced = syncExternalTools('claude', baseUrl, apiKey);
+  const extSynced = syncExternalTools('claude', baseUrl, apiKey, { claudeModelId: modelId, opencodeDefaultModelKey: `yunyi-claude/${modelId}` });
   writeSpinner.succeed('配置写入完成');
 
   console.log(chalk.green('\n✅ Claude 节点配置完成！'));
@@ -2641,6 +3448,9 @@ async function presetClaude(paths, args = {}) {
   console.log(chalk.gray(`   模型: ${modelName}`));
   console.log(chalk.gray('   API Key: 已设置'));
   if (extSynced.length > 0) console.log(chalk.gray(`   同步: ${extSynced.join(', ')}`));
+  if (repairResult.renamedProviders.length > 0) {
+    console.log(chalk.gray(`   已保留并修复冲突 provider: ${repairResult.renamedProviders.map(item => `${item.from}→${item.to}`).join(', ')}`));
+  }
 
   const shouldTestGateway = args.test !== undefined
     ? !['false', '0', 'no'].includes(String(args.test).toLowerCase())
@@ -2701,28 +3511,8 @@ async function presetCodex(paths, args = {}) {
   }
 
   const config = ensureConfigStructure(readConfig(paths.openclawConfig) || {});
-  const existingProviders = Object.keys(config.models.providers || {});
-  const toRemove = existingProviders.filter(name => name !== providerName);
-
-  if (toRemove.length > 0 && !args.force) {
-    const { overwrite } = await inquirer.prompt([{
-      type: 'confirm',
-      name: 'overwrite',
-      message: `检测到已有中转配置: ${existingProviders.join(', ')}，将仅保留 ${providerName}。是否继续？`,
-      default: false
-    }]);
-    if (!overwrite) {
-      console.log(chalk.gray('已取消'));
-      return;
-    }
-  }
-
-  const removedProviders = toRemove.length > 0
-    ? pruneProvidersExcept(config, [providerName])
-    : [];
-  if (removedProviders.length > 0) {
-    pruneAuthProfilesExceptWithSync(paths, [providerName]);
-  }
+  const repairResult = applyConfigRepairsWithSync(config, paths);
+  const removedProviders = repairResult.renamedProviders.map(item => item.from);
 
   const baseUrl = buildFullUrl(selectedEndpoint.url, 'codex');
 
@@ -2826,7 +3616,7 @@ async function presetCodex(paths, args = {}) {
   cleanupConflictingEnvVars(config, baseUrl, apiKey);
   writeConfigWithSync(paths, config);
   updateAuthProfilesWithSync(paths, providerName, apiKey);
-  const extSynced2 = syncExternalTools('codex', baseUrl, apiKey);
+  const extSynced2 = syncExternalTools('codex', baseUrl, apiKey, { modelId });
   writeSpinner2.succeed('配置写入完成');
 
   console.log(chalk.green('\n✅ Codex 节点配置完成！'));
@@ -2835,6 +3625,9 @@ async function presetCodex(paths, args = {}) {
   console.log(chalk.gray(`   模型: ${modelName}`));
   console.log(chalk.gray('   API Key: 已设置'));
   if (extSynced2.length > 0) console.log(chalk.gray(`   同步: ${extSynced2.join(', ')}`));
+  if (repairResult.renamedProviders.length > 0) {
+    console.log(chalk.gray(`   已保留并修复冲突 provider: ${repairResult.renamedProviders.map(item => `${item.from}→${item.to}`).join(', ')}`));
+  }
 
   const shouldTestGateway = args.test !== undefined
     ? !['false', '0', 'no'].includes(String(args.test).toLowerCase())
@@ -2943,6 +3736,7 @@ async function autoActivate(paths, args = {}) {
 
   // ---- 构建配置 ----
   const config = ensureConfigStructure(readConfig(paths.openclawConfig) || {});
+  applyConfigRepairsWithSync(config, paths);
 
   const claudeBaseUrl = buildFullUrl(selectedEndpoint.url, 'claude');
   const codexBaseUrl = buildFullUrl(selectedEndpoint.url, 'codex');
@@ -3012,8 +3806,9 @@ async function autoActivate(paths, args = {}) {
   updateAuthProfilesWithSync(paths, claudeProviderName, apiKey);
   updateAuthProfilesWithSync(paths, codexProviderName, apiKey);
   const extSynced = [];
-  try { syncExternalTools('claude', claudeBaseUrl, apiKey, { codexBaseUrl }); extSynced.push('Claude Code settings'); } catch { /* ignore */ }
-  try { syncExternalTools('codex', codexBaseUrl, apiKey); extSynced.push('Codex CLI config'); } catch { /* ignore */ }
+  const opencodeDefaultModelKey = isClaudePrimary ? `yunyi-claude/${claudeModelId}` : `yunyi-codex/${codexModelId}`;
+  try { extSynced.push(...syncExternalTools('claude', claudeBaseUrl, apiKey, { codexBaseUrl, claudeModelId, opencodeDefaultModelKey })); } catch { /* ignore */ }
+  try { extSynced.push(...syncExternalTools('codex', codexBaseUrl, apiKey, { modelId: codexModelId })); } catch { /* ignore */ }
   writeSpinner.succeed('配置写入完成');
 
   // ---- 输出结果 ----
@@ -3025,7 +3820,7 @@ async function autoActivate(paths, args = {}) {
   console.log(chalk.gray('   API Key: 已设置'));
   if (extSynced.length > 0) console.log(chalk.gray(`   同步: ${extSynced.join(', ')}`));
   console.log(chalk.gray('   若遇 certificate 报错，请新开终端或执行 source ~/.zshrc 后重试（已放宽 TLS 校验）'));
-  console.log(chalk.gray('   使用 OpenCode 时可在界面中切换 Claude Sonnet 4.6 / GPT 5.4；Codex 仅支持 GPT'));
+  console.log(chalk.gray(`   使用 OpenCode 时可在界面中切换 ${getOpencodeSwitchHint()}；Codex 仅支持 GPT`));
 
   const gwPort = config.gateway?.port || 18789;
   const gwToken = config.gateway?.auth?.token;
@@ -3056,8 +3851,7 @@ async function autoActivate(paths, args = {}) {
 // ============ 单独配置 Claude Code CLI ============
 async function activateClaudeCode(paths, args = {}) {
   console.log(chalk.cyan.bold('\n🔧 配置 Claude Code CLI\n'));
-
-  const claudeApiConfig = API_CONFIG.claude;
+  const selectedModel = await promptClaudeModelSelection(args);
 
   // ---- 测速选节点 ----
   const shouldTest = !(args['no-test'] || args.noTest);
@@ -3118,25 +3912,28 @@ async function activateClaudeCode(paths, args = {}) {
   // ---- 写入配置 ----
   const claudeBaseUrl = buildFullUrl(selectedEndpoint.url, 'claude');
   const writeSpinner = ora({ text: '正在写入 Claude Code 配置...', spinner: 'dots' }).start();
-  writeClaudeCodeSettings(claudeBaseUrl, apiKey);
+  writeClaudeCodeSettings(claudeBaseUrl, apiKey, selectedModel.id);
   writeSpinner.succeed('Claude Code 配置写入完成');
 
   console.log(chalk.green('\n✅ Claude Code CLI 配置完成！'));
   console.log(chalk.cyan(`   Base URL: ${claudeBaseUrl}`));
-  console.log(chalk.gray(`   模型: claude-sonnet-4-6`));
+  console.log(chalk.gray(`   模型: ${selectedModel.name} (${selectedModel.id})`));
   console.log(chalk.gray('   API Key: 已设置'));
   console.log(chalk.gray('\n   已写入:'));
   console.log(chalk.gray('   • ~/.claude/settings.json'));
   console.log(chalk.gray('   • ~/.claude.json (跳过 onboarding)'));
-  console.log(chalk.gray('   • shell 环境变量 (ANTHROPIC_BASE_URL, ANTHROPIC_AUTH_TOKEN)'));
+  console.log(chalk.gray('   • shell 环境变量 (ANTHROPIC_BASE_URL, ANTHROPIC_AUTH_TOKEN, ANTHROPIC_MODEL)'));
   console.log(chalk.yellow('\n   提示: 请重新打开终端或执行 source ~/.zshrc 使环境变量生效'));
+
+  if (await confirmImmediateTest(args, '是否立即测试 Claude Code CLI 连接？')) {
+    await testAdditionalCliConnections(args, { only: ['claude'] });
+  }
 }
 
 // ============ 单独配置 Opencode ============
 async function activateOpencode(paths, args = {}) {
   console.log(chalk.cyan.bold('\n🔧 配置 Opencode\n'));
-
-  const claudeApiConfig = API_CONFIG.claude;
+  const defaultModel = await promptOpencodeDefaultModelSelection(args);
 
   // ---- 测速选节点 ----
   const shouldTest = !(args['no-test'] || args.noTest);
@@ -3197,21 +3994,24 @@ async function activateOpencode(paths, args = {}) {
   // ---- 写入配置 ----
   const claudeBaseUrl = buildFullUrl(selectedEndpoint.url, 'claude');
   const codexBaseUrl = buildFullUrl(selectedEndpoint.url, 'codex');
-  const modelId = 'claude-sonnet-4-6';
   const writeSpinner = ora({ text: '正在写入 Opencode 配置...', spinner: 'dots' }).start();
-  const configPath = writeOpencodeConfig(claudeBaseUrl, codexBaseUrl, apiKey, modelId);
+  writeOpencodeConfig(claudeBaseUrl, codexBaseUrl, apiKey, defaultModel.modelKey);
   writeSpinner.succeed('Opencode 配置写入完成');
 
   console.log(chalk.green('\n✅ Opencode 配置完成！'));
-  console.log(chalk.cyan(`   Claude: ${claudeBaseUrl}  →  claude-sonnet-4-6`));
-  console.log(chalk.cyan(`   Codex:  ${codexBaseUrl}  →  gpt-5.4`));
-  console.log(chalk.gray(`   默认模型: yunyi-claude/${modelId}`));
+  console.log(chalk.cyan(`   Claude: ${claudeBaseUrl}  →  ${getClaudeSwitchHint()}`));
+  console.log(chalk.cyan(`   Codex:  ${codexBaseUrl}  →  ${CODEX_MODELS.map(model => model.name).join(' / ')}`));
+  console.log(chalk.gray(`   默认模型: ${defaultModel.modelKey}`));
   console.log(chalk.gray('   API Key: 已设置'));
   console.log(chalk.gray('\n   已写入:'));
   console.log(chalk.gray('   • ~/.config/opencode/opencode.json (CLI + 桌面版)'));
   console.log(chalk.gray('   • ~/.codex/config.toml (model_providers)'));
   console.log(chalk.gray('   • ~/.codex/auth.json (API Keys)'));
-  console.log(chalk.yellow('\n   切换模型: 在 opencode 内使用 /model 命令切换 yunyi-claude / yunyi-codex'));
+  console.log(chalk.yellow(`\n   切换模型: 在 opencode 内使用 /model 命令切换 (${getOpencodeSwitchHint()})`));
+
+  if (await confirmImmediateTest(args, '是否立即测试 Opencode CLI 连接？')) {
+    await testAdditionalCliConnections(args, { only: ['opencode'] });
+  }
 }
 
 // ============ 单独配置 Codex CLI ============
@@ -3219,7 +4019,7 @@ async function activateCodex(paths, args = {}) {
   console.log(chalk.cyan.bold('\n🔧 配置 Codex CLI\n'));
 
   // ---- 选模型 ----
-  let modelId = CODEX_MODELS[0]?.id || 'gpt-5.4';
+  let modelId = getDefaultCodexModel().id;
   if (CODEX_MODELS.length > 1) {
     const { selected } = await inquirer.prompt([{
       type: 'list',
@@ -3301,6 +4101,10 @@ async function activateCodex(paths, args = {}) {
   console.log(chalk.gray('   • ~/.codex/config.toml (model + model_providers)'));
   console.log(chalk.gray('   • ~/.codex/auth.json (OPENAI_API_KEY)'));
   console.log(chalk.yellow('\n   提示: 请重新打开终端使配置生效'));
+
+  if (await confirmImmediateTest(args, '是否立即测试 Codex CLI 连接？')) {
+    await testAdditionalCliConnections(args, { only: ['codex'] });
+  }
 }
 
 // ============ yycode 精简模式（零交互一键配置） ============
@@ -3446,8 +4250,8 @@ async function yycodeQuickSetup(paths) {
   writeConfigWithSync(paths, config);
   updateAuthProfilesWithSync(paths, claudeProviderName, apiKey);
   updateAuthProfilesWithSync(paths, codexProviderName, apiKey);
-  try { syncExternalTools('claude', claudeBaseUrl, apiKey, { codexBaseUrl }); } catch { /* ignore */ }
-  try { syncExternalTools('codex', codexBaseUrl, apiKey); } catch { /* ignore */ }
+  try { syncExternalTools('claude', claudeBaseUrl, apiKey, { codexBaseUrl, claudeModelId, opencodeDefaultModelKey: `yunyi-codex/${codexModelId}` }); } catch { /* ignore */ }
+  try { syncExternalTools('codex', codexBaseUrl, apiKey, { modelId: codexModelId }); } catch { /* ignore */ }
   writeSpinner.succeed('配置写入完成');
 
   // ---- 结果 ----
@@ -3457,7 +4261,7 @@ async function yycodeQuickSetup(paths) {
   console.log(chalk.cyan(`   Codex (主): ${codexBaseUrl}`));
   console.log(chalk.gray(`     模型: ${codexModel.name}`));
   console.log(chalk.gray('   API Key: 已设置'));
-  console.log(chalk.gray('   同步: Claude Code settings, Codex CLI config'));
+  console.log(chalk.gray('   同步: Claude Code settings, Opencode config, Codex CLI config'));
   console.log('');
 }
 
@@ -3529,7 +4333,7 @@ async function main() {
         { name: '  配置 Opencode', value: 'activate_opencode' },
         { name: '  配置 Codex CLI', value: 'activate_codex' },
         new inquirer.Separator('  -- 工具 --'),
-        { name: '  切换模型', value: 'switch_model' },
+        { name: '  切换 OpenClaw 模型', value: 'switch_model' },
         { name: `  权限管理${getToolsProfileTag(paths)}`, value: 'tools_profile' },
         { name: '  测试连接', value: 'test_connection' },
         { name: '  查看配置', value: 'view_config' },
@@ -3774,11 +4578,12 @@ async function activate(paths, type) {
 }
 
 
-// ============ 切换模型 ============
+// ============ 切换 OpenClaw 模型 ============
 async function switchModel(paths) {
-  console.log(chalk.cyan('🔄 切换模型\n'));
+  console.log(chalk.cyan('🔄 切换 OpenClaw 模型\n'));
 
   const config = ensureConfigStructure(readConfig(paths.openclawConfig) || {});
+  applyConfigRepairsWithSync(config, paths);
   const primary = config.agents?.defaults?.model?.primary || '';
   const providers = config.models?.providers || {};
 
@@ -3869,7 +4674,7 @@ async function switchModel(paths) {
   const { selected } = await inquirer.prompt([{
     type: 'list',
     name: 'selected',
-    message: '选择模型:',
+    message: '选择 OpenClaw 模型:',
     default: primaryInPreset ? primary : undefined,
     pageSize: 15,
     choices,
@@ -3879,7 +4684,7 @@ async function switchModel(paths) {
 
   if (selected === '__other__') {
     if (otherModels.length === 0) {
-      console.log(chalk.gray('\n当前配置中没有其他模型，仅有预设模型可用'));
+  console.log(chalk.gray('\n当前 OpenClaw 配置中没有其他模型，仅有预设模型可用'));
       return;
     }
     const otherChoices = otherModels.map(o => {
@@ -4038,12 +4843,13 @@ async function manageToolsProfile(paths) {
 
 // ============ 测试连接 ============
 async function testConnection(paths, args = {}) {
-  console.log(chalk.cyan('🧪 测试 OpenClaw Gateway 连接\n'));
+  console.log(chalk.cyan('🧪 测试 OpenClaw / 各 CLI 连接\n'));
   invalidateGatewayEnvCache();
 
-  const config = readConfig(paths.openclawConfig);
+  const config = ensureConfigStructure(readConfig(paths.openclawConfig) || {});
+  applyConfigRepairsWithSync(config, paths);
 
-  if (!config) {
+  if (!config || !config.models) {
     console.log(chalk.yellow('配置文件不存在，请先选择节点'));
     return;
   }
@@ -4051,7 +4857,7 @@ async function testConnection(paths, args = {}) {
   // 检查当前激活的是哪个
   let primary = config.agents?.defaults?.model?.primary || '';
   if (!primary.includes('/')) {
-    console.log(chalk.yellow('⚠️ 主模型未设置，请先通过「切换模型」或「一键配置」设置主模型'));
+    console.log(chalk.yellow('⚠️ 主模型未设置，请先通过「切换 OpenClaw 模型」或「一键配置」设置主模型'));
     return;
   }
 
@@ -4222,6 +5028,10 @@ async function testConnection(paths, args = {}) {
       if (!cliResult.success) {
         console.log(chalk.red(`\n❌ Gateway CLI 测试失败`));
         console.log(chalk.red(`   错误: ${cliResult.error || '未知错误'}`));
+        if (cliResult.rawError && cliResult.rawError !== cliResult.error) {
+          console.log(chalk.gray(`   原始输出: ${cliResult.rawError.substring(0, 300)}`));
+        }
+        console.log(chalk.gray('   可继续执行: openclaw logs --follow'));
         console.log(chalk.gray(`   将尝试使用 HTTP 端点测试...`));
       }
     }
@@ -4300,6 +5110,8 @@ async function testConnection(paths, args = {}) {
     }
   } catch (error) {
     console.log(chalk.red(`❌ 测试失败: ${error.message}`));
+  } finally {
+    await testAdditionalCliConnections(args);
   }
 }
 
@@ -4725,10 +5537,18 @@ function testGatewayViaAgent(model) {
           // stdout 有 JSON，走正常解析流程而非直接报错
           stdout = fallbackOutput;
         } else {
+          const plainCmd = cmd.replace(/\s--json\b/, '');
+          const plainResult = safeExec(plainCmd, execOpts);
+          const plainCombined = `${plainResult.output || ''}\n${plainResult.stdout || ''}\n${plainResult.stderr || ''}`.trim();
+          const readableError = buildReadableAgentError(
+            `${cleanStderr}\n${fallbackOutput}\n${plainCombined}`,
+            (error.message || 'CLI 执行失败').trim()
+          );
           resolve({
             success: false,
             usedCli: true,
-            error: (cleanStderr || fallbackOutput || error.message || 'CLI 执行失败').trim()
+            error: readableError,
+            rawError: (cleanStderr || fallbackOutput || plainCombined || error.message || 'CLI 执行失败').trim()
           });
           return;
         }