yymaxapi 1.0.103 → 1.0.108

package/README.md

@@ -8,8 +8,14 @@
 ```bash
 npx yymaxapi@latest
 ```
-按提示选择节点和模型即可。
-主菜单已简化为：激活 Claude / 激活 Codex / 测试连接 / 查看配置 / 恢复 / 退出。
+按提示选择模型并输入 Key 即可，默认会直接使用预设默认节点。
+主菜单已简化为：一键配置 / 配置外部工具 / 测速节点 / 测试连接 / 查看配置 / 恢复 / 退出。
+
+**需要手动测速时**
+```bash
+npx yymaxapi@latest speed-test
+```
+或在具体配置命令后追加 `--speed-test`，按测速结果手动选点。
 
 **方式二：一键配置 Claude**
 ```bash

package/bin/yymaxapi.js

@@ -321,6 +321,90 @@ async function promptClaudeModelSelection(args = {}, message = '选择 Claude
   return CLAUDE_MODELS.find(model => model.id === selected) || fallback;
 }
 
+function normalizeHermesModelType(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  if (!normalized) return '';
+  if (['gpt', 'codex', 'openai'].includes(normalized)) return 'codex';
+  if (['claude', 'anthropic'].includes(normalized)) return 'claude';
+  return '';
+}
+
+function resolveHermesModelType(modelId, preferredType = '') {
+  const requestedType = normalizeHermesModelType(preferredType);
+  const inClaude = CLAUDE_MODELS.some(model => model.id === modelId);
+  const inCodex = CODEX_MODELS.some(model => model.id === modelId);
+
+  if (requestedType === 'claude' && (inClaude || !inCodex)) return 'claude';
+  if (requestedType === 'codex' && (inCodex || !inClaude)) return 'codex';
+  if (inCodex && !inClaude) return 'codex';
+  if (inClaude && !inCodex) return 'claude';
+  return requestedType || 'claude';
+}
+
+async function promptHermesModelSelection(args = {}, message = '选择 Hermes 默认模型:') {
+  const requestedModel = (args['model-id'] || args.model || '').toString().trim();
+  const requestedType = normalizeHermesModelType(
+    args.primary || args.type || args.protocol || args.provider || args.runtime
+  );
+  const explicitClaudeModel = (args['claude-model'] || '').toString().trim();
+  const explicitCodexModel = (args['codex-model'] || '').toString().trim();
+
+  let selectedType = requestedType;
+  if (!selectedType && explicitClaudeModel) selectedType = 'claude';
+  if (!selectedType && explicitCodexModel) selectedType = 'codex';
+  if (!selectedType && requestedModel) {
+    selectedType = resolveHermesModelType(requestedModel);
+  }
+
+  if (!selectedType) {
+    if (CLAUDE_MODELS.length > 0 && CODEX_MODELS.length === 0) {
+      selectedType = 'claude';
+    } else if (CODEX_MODELS.length > 0 && CLAUDE_MODELS.length === 0) {
+      selectedType = 'codex';
+    } else {
+      const { selectedType: pickedType } = await inquirer.prompt([{
+        type: 'list',
+        name: 'selectedType',
+        message: '选择 Hermes 模型类型:',
+        choices: [
+          { name: 'Claude', value: 'claude' },
+          { name: 'GPT', value: 'codex' }
+        ],
+        default: 'claude'
+      }]);
+      selectedType = pickedType;
+    }
+  }
+
+  const modelList = selectedType === 'codex' ? CODEX_MODELS : CLAUDE_MODELS;
+  const fallbackModel = modelList[0] || (selectedType === 'codex' ? getDefaultCodexModel() : getDefaultClaudeModel());
+  const explicitModelId = selectedType === 'codex'
+    ? (explicitCodexModel || requestedModel)
+    : (explicitClaudeModel || requestedModel);
+
+  if (explicitModelId) {
+    const model = modelList.find(item => item.id === explicitModelId) || { id: explicitModelId, name: explicitModelId };
+    return { type: selectedType, model };
+  }
+
+  if (modelList.length <= 1) {
+    return { type: selectedType, model: fallbackModel };
+  }
+
+  const { selected } = await inquirer.prompt([{
+    type: 'list',
+    name: 'selected',
+    message,
+    choices: modelList.map(model => ({ name: model.name, value: model.id })),
+    default: fallbackModel.id
+  }]);
+
+  return {
+    type: selectedType,
+    model: modelList.find(model => model.id === selected) || fallbackModel
+  };
+}
+
 async function promptOpencodeDefaultModelSelection(args = {}, message = '选择 Opencode 默认模型:') {
   const fallbackClaude = getDefaultClaudeModel();
   const fallbackCodex = getDefaultCodexModel();
@@ -523,6 +607,77 @@ async function testFallbackEndpoints() {
   return testAllEndpoints(FALLBACK_EPS, { label: '检测备用节点', autoFallback: false });
 }
 
+function shouldRunEndpointSpeedTest(args = {}) {
+  const raw = args['speed-test'] !== undefined ? args['speed-test'] : args.speedTest;
+  if (raw === undefined) return false;
+  if (typeof raw === 'string') {
+    return !['false', '0', 'no'].includes(raw.toLowerCase());
+  }
+  return !!raw;
+}
+
+async function resolveEndpointSelection(args = {}, options = {}) {
+  const defaultEndpoint = options.defaultEndpoint || ENDPOINTS[0];
+  if (!defaultEndpoint) return null;
+  if (!shouldRunEndpointSpeedTest(args)) return defaultEndpoint;
+
+  const speedIntro = options.speedIntro || '📡 开始测速节点...\n';
+  const proceedMessage = options.proceedMessage || '仍要写入默认节点配置吗？';
+  const chooseMessage = options.chooseMessage || '选择节点:';
+
+  console.log(chalk.cyan(`${speedIntro}`));
+  const speedResult = await testAllEndpoints(ENDPOINTS, { autoFallback: true });
+  const sorted = speedResult.ranked || [];
+
+  if (sorted.length > 0) {
+    const { selectedIndex } = await inquirer.prompt([{
+      type: 'list',
+      name: 'selectedIndex',
+      message: chooseMessage,
+      choices: [
+        { name: `* 使用默认节点 (${defaultEndpoint.name})`, value: -1 },
+        new inquirer.Separator('  ---- 或按测速结果选择 ----'),
+        ...sorted.map((endpoint, index) => ({
+          name: `${endpoint.name} - ${endpoint.latency}ms (评分:${endpoint.score})`,
+          value: index
+        }))
+      ]
+    }]);
+
+    const selectedEndpoint = selectedIndex === -1 ? defaultEndpoint : sorted[selectedIndex];
+    if (speedResult.usedFallback) {
+      console.log(chalk.yellow('\n⚠ 当前使用备用节点\n'));
+    }
+    return selectedEndpoint;
+  }
+
+  console.log(chalk.red('\n⚠️  所有节点（含备用）均不可达'));
+  const { proceed } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'proceed',
+    message: proceedMessage,
+    default: false
+  }]);
+  if (!proceed) {
+    console.log(chalk.gray('已取消'));
+    return null;
+  }
+  return defaultEndpoint;
+}
+
+async function speedTestNodes() {
+  console.log(chalk.cyan.bold('\n📡 节点测速\n'));
+  const speedResult = await testAllEndpoints(ENDPOINTS, { autoFallback: true });
+  const defaultEndpoint = ENDPOINTS[0];
+
+  if (defaultEndpoint) {
+    console.log(chalk.gray(`\n默认配置当前直连: ${defaultEndpoint.name} (${defaultEndpoint.url})`));
+  }
+  if (speedResult.best && defaultEndpoint && speedResult.best.url !== defaultEndpoint.url) {
+    console.log(chalk.yellow('如需按测速结果选点，可在对应配置命令后追加 --speed-test'));
+  }
+}
+
 // ============ API Key 验证 ============
 function httpGetJson(url, headers = {}, timeout = 10000) {
   return new Promise((resolve, reject) => {
@@ -883,11 +1038,13 @@ function writeClaudeCodeSettings(baseUrl, apiKey, modelId = getDefaultClaudeMode
     if (fs.existsSync(settingsPath)) {
       try { settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8')); } catch { settings = {}; }
     }
-    settings.apiBaseUrl = baseUrl.replace(/\/+$/, '');
+    const normalizedBaseUrl = baseUrl.replace(/\/+$/, '');
+    settings.apiBaseUrl = normalizedBaseUrl;
     if (!settings.env) settings.env = {};
-    settings.env.ANTHROPIC_AUTH_TOKEN = apiKey;
+    settings.env.ANTHROPIC_API_KEY = apiKey;
+    settings.env.ANTHROPIC_BASE_URL = normalizedBaseUrl;
+    delete settings.env.ANTHROPIC_AUTH_TOKEN;
     delete settings.availableModels;
-    delete settings.env.ANTHROPIC_BASE_URL;
     delete settings.env.ANTHROPIC_MODEL;
     if (!fs.existsSync(claudeDir)) fs.mkdirSync(claudeDir, { recursive: true });
     fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
@@ -1075,12 +1232,16 @@ function writeOpencodeConfig(claudeBaseUrl, codexBaseUrl, apiKey, defaultModelKe
   return configPath;
 }
 
-function writeHermesConfig(baseUrl, apiKey, modelId = getDefaultClaudeModel().id) {
+function writeHermesConfig(baseUrl, apiKey, modelId = getDefaultClaudeModel().id, options = {}) {
   const dataDir = getHermesDataDir();
   const configPath = path.join(dataDir, 'config.yaml');
   const envPath = getHermesEnvPath();
   const existingConfigPath = getHermesConfigPath();
   const wslMirror = getHermesWslMirrorInfo();
+  const modelType = options.type || options.provider || '';
+  const resolvedType = resolveHermesModelType(modelId, modelType);
+  const runtimeProvider = resolvedType === 'codex' ? 'custom' : 'anthropic';
+  const apiMode = resolvedType === 'codex' ? 'codex_responses' : 'anthropic_messages';
 
   let existingConfigRaw = readTextIfExists(existingConfigPath);
   if (!existingConfigRaw && wslMirror.sourceConfigPath) {
@@ -1092,15 +1253,25 @@ function writeHermesConfig(baseUrl, apiKey, modelId = getDefaultClaudeModel().id
     existingEnvRaw = readWslTextFile(wslMirror.envPath);
   }
 
-  const normalizedBaseUrl = trimClaudeMessagesSuffix(String(baseUrl || '').trim()).replace(/\/+$/, '');
-  const nextConfigRaw = upsertSimpleYamlConfig(existingConfigRaw, {
-    provider: 'anthropic',
-    model: modelId,
-    base_url: normalizedBaseUrl
-  });
-  const nextEnvRaw = upsertEnvFile(existingEnvRaw, {
-    ANTHROPIC_API_KEY: String(apiKey || '').trim()
+  const normalizedBaseUrl = (
+    resolvedType === 'codex'
+      ? trimOpenAiEndpointSuffix(String(baseUrl || '').trim())
+      : trimClaudeMessagesSuffix(String(baseUrl || '').trim())
+  ).replace(/\/+$/, '');
+  const existingConfig = parseSimpleYamlConfig(existingConfigRaw);
+  const existingModelConfig = existingConfig.model && !Array.isArray(existingConfig.model) && typeof existingConfig.model === 'object'
+    ? existingConfig.model
+    : {};
+  const nextConfigRaw = upsertHermesModelConfig(existingConfigRaw, {
+    ...existingModelConfig,
+    default: modelId,
+    provider: runtimeProvider,
+    base_url: normalizedBaseUrl,
+    api_mode: apiMode
   });
+  const envEntries = {};
+  envEntries[resolvedType === 'codex' ? 'OPENAI_API_KEY' : 'ANTHROPIC_API_KEY'] = String(apiKey || '').trim();
+  const nextEnvRaw = upsertEnvFile(existingEnvRaw, envEntries);
 
   if (!fs.existsSync(dataDir)) fs.mkdirSync(dataDir, { recursive: true });
   fs.writeFileSync(configPath, nextConfigRaw, 'utf8');
@@ -1120,6 +1291,9 @@ function writeHermesConfig(baseUrl, apiKey, modelId = getDefaultClaudeModel().id
     wslConfigPath: wslMirror.configPath,
     wslEnvPath: wslMirror.envPath,
     modelId,
+    modelType: resolvedType,
+    provider: runtimeProvider,
+    apiMode,
     baseUrl: normalizedBaseUrl
   };
 }
@@ -3508,24 +3682,58 @@ function readWslTextFile(filePath) {
   return result.ok ? (result.output || result.stdout || '') : '';
 }
 
+function parseYamlScalar(value) {
+  let normalized = String(value ?? '').trim();
+  if (
+    (normalized.startsWith('"') && normalized.endsWith('"'))
+    || (normalized.startsWith('\'') && normalized.endsWith('\''))
+  ) {
+    try {
+      normalized = JSON.parse(normalized);
+    } catch {
+      normalized = normalized.slice(1, -1);
+    }
+  }
+  return normalized;
+}
+
 function parseSimpleYamlConfig(text) {
   const config = {};
+  let currentObjectKey = '';
+
   for (const line of String(text || '').split(/\r?\n/)) {
-    const match = line.match(/^([A-Za-z0-9_-]+)\s*:\s*(.*?)\s*$/);
-    if (!match) continue;
-    let value = match[2].trim();
-    if (
-      (value.startsWith('"') && value.endsWith('"'))
-      || (value.startsWith('\'') && value.endsWith('\''))
-    ) {
-      try {
-        value = JSON.parse(value);
-      } catch {
-        value = value.slice(1, -1);
+    if (!line.trim() || line.trim().startsWith('#')) continue;
+
+    const topLevelMatch = line.match(/^([A-Za-z0-9_-]+)\s*:\s*(.*?)\s*$/);
+    if (topLevelMatch && !line.startsWith(' ')) {
+      const key = topLevelMatch[1];
+      const rawValue = topLevelMatch[2];
+      if (rawValue === '') {
+        if (!config[key] || typeof config[key] !== 'object' || Array.isArray(config[key])) {
+          config[key] = {};
+        }
+        currentObjectKey = key;
+      } else {
+        config[key] = parseYamlScalar(rawValue);
+        currentObjectKey = '';
+      }
+      continue;
+    }
+
+    if (currentObjectKey) {
+      const nestedMatch = line.match(/^\s{2}([A-Za-z0-9_-]+)\s*:\s*(.*?)\s*$/);
+      if (nestedMatch) {
+        if (!config[currentObjectKey] || typeof config[currentObjectKey] !== 'object' || Array.isArray(config[currentObjectKey])) {
+          config[currentObjectKey] = {};
+        }
+        config[currentObjectKey][nestedMatch[1]] = parseYamlScalar(nestedMatch[2]);
+        continue;
       }
     }
-    config[match[1]] = value;
+
+    currentObjectKey = '';
   }
+
   return config;
 }
 
@@ -3533,31 +3741,71 @@ function serializeYamlScalar(value) {
   return JSON.stringify(String(value ?? ''));
 }
 
-function upsertSimpleYamlConfig(text, entries) {
-  const lines = String(text || '').replace(/\r\n/g, '\n').split('\n');
-  const normalized = lines.length === 1 && lines[0] === '' ? [] : [...lines];
-  const seen = new Set();
+function buildHermesModelConfigBlock(entries) {
+  const ordered = {};
+  for (const key of ['default', 'provider', 'base_url', 'api_mode']) {
+    if (Object.prototype.hasOwnProperty.call(entries, key)) {
+      ordered[key] = entries[key];
+    }
+  }
+  for (const [key, value] of Object.entries(entries)) {
+    if (!Object.prototype.hasOwnProperty.call(ordered, key)) {
+      ordered[key] = value;
+    }
+  }
 
-  for (let i = 0; i < normalized.length; i += 1) {
-    const match = normalized[i].match(/^([A-Za-z0-9_-]+)\s*:\s*.*$/);
-    if (!match) continue;
-    const key = match[1];
-    if (!Object.prototype.hasOwnProperty.call(entries, key)) continue;
-    normalized[i] = `${key}: ${serializeYamlScalar(entries[key])}`;
-    seen.add(key);
+  const lines = ['model:'];
+  for (const [key, value] of Object.entries(ordered)) {
+    if (value === undefined || value === null || value === '') continue;
+    lines.push(`  ${key}: ${serializeYamlScalar(value)}`);
   }
+  return lines.join('\n');
+}
 
-  for (const key of Object.keys(entries)) {
-    if (!seen.has(key)) {
-      normalized.push(`${key}: ${serializeYamlScalar(entries[key])}`);
+function upsertHermesModelConfig(text, modelEntries) {
+  let normalized = String(text || '').replace(/\r\n/g, '\n');
+  normalized = normalized.replace(/^(provider|base_url|api_mode):\s*.*\n?/gm, '');
+
+  const lines = normalized.split('\n');
+  const output = [];
+  let replaced = false;
+
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (/^model:\s*(.*)$/.test(line)) {
+      replaced = true;
+      if (output.length > 0 && output[output.length - 1] !== '') {
+        output.push('');
+      }
+      output.push(buildHermesModelConfigBlock(modelEntries));
+
+      i += 1;
+      while (i < lines.length) {
+        const nextLine = lines[i];
+        if (/^\s{2,}/.test(nextLine)) {
+          i += 1;
+          continue;
+        }
+        if (nextLine === '') {
+          break;
+        }
+        i -= 1;
+        break;
+      }
+      continue;
     }
+    output.push(line);
   }
 
-  while (normalized.length > 0 && normalized[normalized.length - 1] === '') {
-    normalized.pop();
+  while (output.length > 0 && output[output.length - 1] === '') {
+    output.pop();
+  }
+  if (!replaced) {
+    if (output.length > 0) output.push('');
+    output.push(buildHermesModelConfigBlock(modelEntries));
   }
 
-  return normalized.join('\n') + '\n';
+  return output.join('\n').replace(/\n{3,}/g, '\n\n').trim() + '\n';
 }
 
 function parseEnvFile(text) {
@@ -3620,6 +3868,32 @@ function readHermesYamlConfig(configPath = getHermesConfigPath()) {
   };
 }
 
+function readHermesCliConfig() {
+  const yamlConfig = readHermesYamlConfig();
+  const envPath = getHermesEnvPath();
+  const envEntries = parseEnvFile(readTextIfExists(envPath));
+  const modelConfig = yamlConfig.config?.model && typeof yamlConfig.config.model === 'object'
+    ? yamlConfig.config.model
+    : {};
+  const modelId = String(modelConfig.default || '').trim() || getDefaultClaudeModel().id;
+  const provider = String(modelConfig.provider || '').trim().toLowerCase();
+  const type = resolveHermesModelType(modelId, provider);
+  const apiKey = type === 'codex'
+    ? (envEntries.OPENAI_API_KEY || process.env.OPENAI_API_KEY || process.env.OPENAI_AUTH_TOKEN || '')
+    : (envEntries.ANTHROPIC_API_KEY || envEntries.ANTHROPIC_TOKEN || process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_TOKEN || process.env.CLAUDE_CODE_OAUTH_TOKEN || '');
+
+  return {
+    configPath: yamlConfig.configPath,
+    envPath,
+    configured: yamlConfig.configured || fs.existsSync(envPath),
+    modelId,
+    provider,
+    type,
+    baseUrl: String(modelConfig.base_url || '').trim(),
+    apiKey
+  };
+}
+
 function getOpencodeConfigPath() {
   const home = os.homedir();
   return process.platform === 'win32'
@@ -3638,11 +3912,20 @@ function getCodexCliPaths() {
 function readClaudeCodeCliConfig() {
   const settingsPath = getClaudeCodeSettingsPath();
   const settings = readJsonIfExists(settingsPath) || {};
+  const settingsEnv = settings.env && typeof settings.env === 'object' ? settings.env : {};
+  const settingsApiKey = String(settingsEnv.ANTHROPIC_API_KEY || '').trim();
+  const settingsLegacyAuthToken = String(settingsEnv.ANTHROPIC_AUTH_TOKEN || '').trim();
+  const settingsBaseUrl = String(settingsEnv.ANTHROPIC_BASE_URL || settings.apiBaseUrl || '').trim();
   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 || '',
+    modelId: settings.model || settingsEnv.ANTHROPIC_MODEL || process.env.ANTHROPIC_MODEL || getDefaultClaudeModel().id,
+    baseUrl: settingsBaseUrl || process.env.ANTHROPIC_BASE_URL || '',
+    apiKey: settingsApiKey || settingsLegacyAuthToken || process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || process.env.CLAUDE_API_KEY || '',
+    settingsBaseUrl,
+    settingsApiKey,
+    settingsLegacyAuthToken,
+    hasLegacyAuthTokenInSettings: !!settingsLegacyAuthToken,
+    usesLegacyAuthTokenOnly: !settingsApiKey && !!settingsLegacyAuthToken,
     configured: fs.existsSync(settingsPath)
   };
 }
@@ -3697,6 +3980,23 @@ function summarizeCliTestOutput(text) {
   return lines[0].slice(0, 160);
 }
 
+function extractHermesCliReply(text) {
+  const lines = cleanCliTestOutput(text)
+    .split('\n')
+    .map(line => line.trim())
+    .filter(Boolean)
+    .filter(line => !/^session_id:/i.test(line))
+    .filter(line => !/^resume this session/i.test(line))
+    .filter(line => !/^session:/i.test(line))
+    .filter(line => !/^duration:/i.test(line))
+    .filter(line => !/^messages:/i.test(line))
+    .filter(line => !/^[╭╰│─]+/.test(line));
+
+  const okLine = lines.find(line => /^OK$/i.test(line));
+  if (okLine) return okLine;
+  return lines[0] || '';
+}
+
 function buildReadableAgentError(text, fallback = '') {
   const cleaned = cleanCliTestOutput(text);
   if (!cleaned) return fallback;
@@ -3712,6 +4012,11 @@ function looksLikeCliTestError(text) {
     'all models failed',
     'auth_permanent',
     'auth issue',
+    'authentication_error',
+    'failed to authenticate',
+    'invalid bearer token',
+    'invalid api key',
+    'fix external api key',
     'unauthorized',
     'forbidden',
     'missing environment variable',
@@ -3739,17 +4044,28 @@ function testClaudeCodeCliConnection() {
 
   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' };
+  if (config.usesLegacyAuthTokenOnly) {
+    return {
+      name: 'Claude Code CLI',
+      status: 'failed',
+      detail: '检测到旧版 Claude Code 配置字段 ANTHROPIC_AUTH_TOKEN，请重新运行 yymaxapi 以改写为 ANTHROPIC_API_KEY'
+    };
+  }
+  if (!config.settingsBaseUrl || !config.settingsApiKey) {
+    return { name: 'Claude Code CLI', status: 'failed', detail: 'Claude Code 配置缺少 settings.json 中的 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'
   };
+  delete env.ANTHROPIC_BASE_URL;
+  delete env.ANTHROPIC_API_KEY;
+  delete env.ANTHROPIC_AUTH_TOKEN;
+  delete env.ANTHROPIC_MODEL;
+  delete env.CLAUDE_API_KEY;
 
   return runCliTestCandidates('Claude Code CLI', [
     `${shellQuote(cliBinary)} -p --model ${shellQuote(config.modelId)} --output-format text ${shellQuote('请只回复 OK')}`,
@@ -3801,14 +4117,62 @@ function testCodexCliConnection() {
   ], env);
 }
 
+function testHermesCliConnection() {
+  const cliBinary = resolveCommandBinary('hermes');
+  if (!cliBinary) return { name: 'Hermes CLI', status: 'skipped', detail: '未安装 hermes 命令' };
+
+  const config = readHermesCliConfig();
+  if (!config.configured) return { name: 'Hermes CLI', status: 'skipped', detail: '未检测到 ~/.hermes/config.yaml 或 ~/.hermes/.env' };
+  if (!config.apiKey) return { name: 'Hermes CLI', status: 'failed', detail: 'Hermes 配置缺少 API Key' };
+
+  const env = {
+    ...process.env,
+    PATH: extendPathEnv(null),
+    NODE_TLS_REJECT_UNAUTHORIZED: '0',
+    NODE_NO_WARNINGS: '1'
+  };
+
+  if (config.type === 'codex') {
+    env.OPENAI_API_KEY = config.apiKey;
+    delete env.ANTHROPIC_API_KEY;
+    delete env.ANTHROPIC_TOKEN;
+    delete env.CLAUDE_CODE_OAUTH_TOKEN;
+  } else {
+    env.ANTHROPIC_API_KEY = config.apiKey;
+    if (config.baseUrl) env.ANTHROPIC_BASE_URL = config.baseUrl;
+    delete env.ANTHROPIC_TOKEN;
+    delete env.CLAUDE_CODE_OAUTH_TOKEN;
+  }
+
+  const providerArg = config.provider === 'anthropic' ? ' --provider anthropic' : '';
+  const result = safeExec(`${shellQuote(cliBinary)} chat -Q -q ${shellQuote('请只回复 OK')}${providerArg}`, {
+    timeout: 120000,
+    env,
+    maxBuffer: 1024 * 1024
+  });
+  const combined = cleanCliTestOutput(`${result.output || ''}\n${result.stdout || ''}\n${result.stderr || ''}`);
+  const reply = extractHermesCliReply(combined);
+
+  if (result.ok && /^OK$/i.test(reply) && !looksLikeCliTestError(combined)) {
+    return { name: 'Hermes CLI', status: 'success', detail: 'OK' };
+  }
+
+  return {
+    name: 'Hermes CLI',
+    status: 'failed',
+    detail: reply || summarizeCliTestOutput(combined) || result.error || '命令执行失败'
+  };
+}
+
 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 requested = new Set((options.only || ['claude', 'opencode', 'codex', 'hermes']).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 (requested.has('hermes')) results.push(testHermesCliConnection());
   if (results.length === 0) return;
 
   console.log(chalk.cyan('\n附加测试: 其他 CLI 连接...'));
@@ -4332,6 +4696,27 @@ function trimClaudeMessagesSuffix(baseUrl) {
   return trimmed;
 }
 
+function trimOpenAiEndpointSuffix(baseUrl) {
+  const trimmed = baseUrl.trim();
+  const suffixes = [
+    '/v1/responses',
+    '/responses',
+    '/v1/chat/completions',
+    '/chat/completions',
+    '/v1/models',
+    '/models',
+    '/v1'
+  ];
+
+  for (const suffix of suffixes) {
+    if (trimmed.endsWith(suffix)) {
+      return trimmed.slice(0, -suffix.length);
+    }
+  }
+
+  return trimmed;
+}
+
 async function quickSetup(paths, args = {}) {
   console.log(chalk.cyan.bold('\n🚀 快速配置向导\n'));
 
@@ -4474,47 +4859,15 @@ async function quickSetup(paths, args = {}) {
 }
 
 async function presetClaude(paths, args = {}) {
-  console.log(chalk.cyan.bold('\n🚀 Claude 快速配置（自动测速推荐节点）\n'));
+  console.log(chalk.cyan.bold('\n🚀 Claude 快速配置（默认节点直连）\n'));
 
   const apiConfig = API_CONFIG.claude;
   const providerPrefix = (args['provider-prefix'] || args.prefix || apiConfig.providerName).toString().trim() || apiConfig.providerName;
-
-  const shouldTest = !(args['no-test'] || args.noTest);
-  let selectedEndpoint = ENDPOINTS[0];
-
-  if (shouldTest) {
-    console.log(chalk.cyan('📡 开始测速 Claude 节点...\n'));
-    const speedResult = await testAllEndpoints(ENDPOINTS, { autoFallback: true });
-
-    const sorted = speedResult.ranked || [];
-    if (sorted.length > 0) {
-      const defaultEp = ENDPOINTS[0];
-      const { selectedIndex } = await inquirer.prompt([{
-        type: 'list',
-        name: 'selectedIndex',
-        message: '选择节点:',
-        choices: [
-          { name: `* 使用默认节点 (${defaultEp.name})`, value: -1 },
-          new inquirer.Separator('  ---- 或按测速结果选择 ----'),
-          ...sorted.map((e, i) => ({
-            name: `${e.name} - ${e.latency}ms (评分:${e.score})`,
-            value: i
-          }))
-        ]
-      }]);
-      selectedEndpoint = selectedIndex === -1 ? defaultEp : sorted[selectedIndex];
-      if (speedResult.usedFallback) {
-        console.log(chalk.yellow(`\n⚠ 当前使用备用节点\n`));
-      }
-    } else {
-      console.log(chalk.red('\n⚠️  所有节点（含备用）均不可达'));
-      const { proceed } = await inquirer.prompt([{
-        type: 'confirm', name: 'proceed',
-        message: '仍要写入默认节点配置吗？', default: false
-      }]);
-      if (!proceed) { console.log(chalk.gray('已取消')); return; }
-    }
-  }
+  const selectedEndpoint = await resolveEndpointSelection(args, {
+    speedIntro: '📡 开始测速 Claude 节点...\n',
+    proceedMessage: '仍要写入默认节点配置吗？'
+  });
+  if (!selectedEndpoint) return;
 
   const config = ensureConfigStructure(readConfig(paths.openclawConfig) || {});
   const repairResult = applyConfigRepairsWithSync(config, paths);
@@ -4526,6 +4879,8 @@ async function presetClaude(paths, args = {}) {
 
   const apiKeyEnvFallbacks = [
     'OPENCLAW_CLAUDE_KEY',
+    'ANTHROPIC_API_KEY',
+    'ANTHROPIC_AUTH_TOKEN',
     'CLAUDE_API_KEY',
     'OPENCLAW_API_KEY'
   ];
@@ -4657,48 +5012,16 @@ async function presetClaude(paths, args = {}) {
 }
 
 async function presetCodex(paths, args = {}) {
-  console.log(chalk.cyan.bold('\n🚀 Codex 快速配置（自动测速推荐节点）\n'));
+  console.log(chalk.cyan.bold('\n🚀 Codex 快速配置（默认节点直连）\n'));
 
   const apiConfig = API_CONFIG.codex;
   const providerPrefix = (args['provider-prefix'] || args.prefix || apiConfig.providerName).toString().trim() || apiConfig.providerName;
   const providerName = (args['provider-name'] || args.provider || providerPrefix).toString().trim() || apiConfig.providerName;
-
-  const shouldTest = !(args['no-test'] || args.noTest);
-  let selectedEndpoint = ENDPOINTS[0];
-
-  if (shouldTest) {
-    console.log(chalk.cyan('📡 开始测速 Codex 节点...\n'));
-    const speedResult = await testAllEndpoints(ENDPOINTS, { autoFallback: true });
-
-    const sorted = speedResult.ranked || [];
-    if (sorted.length > 0) {
-      const defaultEp = ENDPOINTS[0];
-      const { selectedIndex } = await inquirer.prompt([{
-        type: 'list',
-        name: 'selectedIndex',
-        message: '选择节点:',
-        choices: [
-          { name: `* 使用默认节点 (${defaultEp.name})`, value: -1 },
-          new inquirer.Separator('  ---- 或按测速结果选择 ----'),
-          ...sorted.map((e, i) => ({
-            name: `${e.name} - ${e.latency}ms (评分:${e.score})`,
-            value: i
-          }))
-        ]
-      }]);
-      selectedEndpoint = selectedIndex === -1 ? defaultEp : sorted[selectedIndex];
-      if (speedResult.usedFallback) {
-        console.log(chalk.yellow(`\n⚠ 当前使用备用节点\n`));
-      }
-    } else {
-      console.log(chalk.red('\n⚠️  所有节点（含备用）均不可达'));
-      const { proceed } = await inquirer.prompt([{
-        type: 'confirm', name: 'proceed',
-        message: '仍要写入默认节点配置吗？', default: false
-      }]);
-      if (!proceed) { console.log(chalk.gray('已取消')); return; }
-    }
-  }
+  const selectedEndpoint = await resolveEndpointSelection(args, {
+    speedIntro: '📡 开始测速 Codex 节点...\n',
+    proceedMessage: '仍要写入默认节点配置吗？'
+  });
+  if (!selectedEndpoint) return;
 
   const config = ensureConfigStructure(readConfig(paths.openclawConfig) || {});
   const repairResult = applyConfigRepairsWithSync(config, paths);
@@ -4852,6 +5175,8 @@ async function autoActivate(paths, args = {}) {
   const apiKeyEnvFallbacks = [
     'OPENCLAW_CLAUDE_KEY',
     'OPENCLAW_CODEX_KEY',
+    'ANTHROPIC_API_KEY',
+    'ANTHROPIC_AUTH_TOKEN',
     'CLAUDE_API_KEY',
     'OPENAI_API_KEY',
     'OPENCLAW_API_KEY'
@@ -5062,40 +5387,10 @@ async function autoActivate(paths, args = {}) {
 async function activateClaudeCode(paths, args = {}) {
   console.log(chalk.cyan.bold('\n🔧 配置 Claude Code CLI\n'));
   const selectedModel = await promptClaudeModelSelection(args);
-
-  // ---- 测速选节点 ----
-  const shouldTest = !(args['no-test'] || args.noTest);
-  let selectedEndpoint = ENDPOINTS[0];
-
-  if (shouldTest) {
-    console.log(chalk.cyan('📡 开始测速节点...\n'));
-    const speedResult = await testAllEndpoints(ENDPOINTS, { autoFallback: true });
-    const sorted = speedResult.ranked || [];
-    if (sorted.length > 0) {
-      const defaultEp = ENDPOINTS[0];
-      const { selectedIndex } = await inquirer.prompt([{
-        type: 'list',
-        name: 'selectedIndex',
-        message: '选择节点:',
-        choices: [
-          { name: `* 使用默认节点 (${defaultEp.name})`, value: -1 },
-          new inquirer.Separator('  ---- 或按测速结果选择 ----'),
-          ...sorted.map((e, i) => ({
-            name: `${e.name} - ${e.latency}ms (评分:${e.score})`,
-            value: i
-          }))
-        ]
-      }]);
-      selectedEndpoint = selectedIndex === -1 ? defaultEp : sorted[selectedIndex];
-    } else {
-      console.log(chalk.red('\n⚠️  所有节点均不可达'));
-      const { proceed } = await inquirer.prompt([{
-        type: 'confirm', name: 'proceed',
-        message: '仍要使用默认节点配置吗？', default: false
-      }]);
-      if (!proceed) { console.log(chalk.gray('已取消')); return; }
-    }
-  }
+  const selectedEndpoint = await resolveEndpointSelection(args, {
+    proceedMessage: '仍要使用默认节点配置吗？'
+  });
+  if (!selectedEndpoint) return;
 
   // ---- API Key ----
   const directKey = (args['api-key'] || args.apiKey || args.key || '').toString().trim();
@@ -5103,7 +5398,7 @@ async function activateClaudeCode(paths, args = {}) {
   if (directKey) {
     apiKey = directKey;
   } else {
-    const envKey = process.env.ANTHROPIC_AUTH_TOKEN || process.env.CLAUDE_API_KEY || '';
+    const envKey = process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || process.env.CLAUDE_API_KEY || '';
     apiKey = await promptApiKey('请输入 API Key:', envKey);
   }
   if (!apiKey) { console.log(chalk.gray('已取消')); return; }
@@ -5131,7 +5426,7 @@ async function activateClaudeCode(paths, args = {}) {
   console.log(chalk.gray('   API Key: 已设置'));
   console.log(chalk.gray('\n   已写入:'));
   console.log(chalk.gray('   • ~/.claude/settings.json'));
-  console.log(chalk.gray('   • 最小字段: apiBaseUrl + env.ANTHROPIC_AUTH_TOKEN'));
+  console.log(chalk.gray('   • 最小字段: apiBaseUrl + env.ANTHROPIC_API_KEY + env.ANTHROPIC_BASE_URL'));
   console.log(chalk.yellow('\n   提示: 如果 Claude Code 已在运行，重新打开一个会话即可读取新配置'));
 
   if (await confirmImmediateTest(args, '是否立即测试 Claude Code CLI 连接？')) {
@@ -5143,40 +5438,10 @@ async function activateClaudeCode(paths, args = {}) {
 async function activateOpencode(paths, args = {}) {
   console.log(chalk.cyan.bold('\n🔧 配置 Opencode\n'));
   const defaultModel = await promptOpencodeDefaultModelSelection(args);
-
-  // ---- 测速选节点 ----
-  const shouldTest = !(args['no-test'] || args.noTest);
-  let selectedEndpoint = ENDPOINTS[0];
-
-  if (shouldTest) {
-    console.log(chalk.cyan('📡 开始测速节点...\n'));
-    const speedResult = await testAllEndpoints(ENDPOINTS, { autoFallback: true });
-    const sorted = speedResult.ranked || [];
-    if (sorted.length > 0) {
-      const defaultEp = ENDPOINTS[0];
-      const { selectedIndex } = await inquirer.prompt([{
-        type: 'list',
-        name: 'selectedIndex',
-        message: '选择节点:',
-        choices: [
-          { name: `* 使用默认节点 (${defaultEp.name})`, value: -1 },
-          new inquirer.Separator('  ---- 或按测速结果选择 ----'),
-          ...sorted.map((e, i) => ({
-            name: `${e.name} - ${e.latency}ms (评分:${e.score})`,
-            value: i
-          }))
-        ]
-      }]);
-      selectedEndpoint = selectedIndex === -1 ? defaultEp : sorted[selectedIndex];
-    } else {
-      console.log(chalk.red('\n⚠️  所有节点均不可达'));
-      const { proceed } = await inquirer.prompt([{
-        type: 'confirm', name: 'proceed',
-        message: '仍要使用默认节点配置吗？', default: false
-      }]);
-      if (!proceed) { console.log(chalk.gray('已取消')); return; }
-    }
-  }
+  const selectedEndpoint = await resolveEndpointSelection(args, {
+    proceedMessage: '仍要使用默认节点配置吗？'
+  });
+  if (!selectedEndpoint) return;
 
   // ---- API Key ----
   const directKey = (args['api-key'] || args.apiKey || args.key || '').toString().trim();
@@ -5184,7 +5449,7 @@ async function activateOpencode(paths, args = {}) {
   if (directKey) {
     apiKey = directKey;
   } else {
-    const envKey = process.env.ANTHROPIC_AUTH_TOKEN || process.env.CLAUDE_API_KEY || '';
+    const envKey = process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || process.env.CLAUDE_API_KEY || '';
     apiKey = await promptApiKey('请输入 API Key:', envKey);
   }
   if (!apiKey) { console.log(chalk.gray('已取消')); return; }
@@ -5240,39 +5505,10 @@ async function activateCodex(paths, args = {}) {
   }
   const modelConfig = CODEX_MODELS.find(m => m.id === modelId) || { id: modelId, name: modelId };
 
-  // ---- 测速选节点 ----
-  const shouldTest = !(args['no-test'] || args.noTest);
-  let selectedEndpoint = ENDPOINTS[0];
-
-  if (shouldTest) {
-    console.log(chalk.cyan('📡 开始测速节点...\n'));
-    const speedResult = await testAllEndpoints(ENDPOINTS, { autoFallback: true });
-    const sorted = speedResult.ranked || [];
-    if (sorted.length > 0) {
-      const defaultEp = ENDPOINTS[0];
-      const { selectedIndex } = await inquirer.prompt([{
-        type: 'list',
-        name: 'selectedIndex',
-        message: '选择节点:',
-        choices: [
-          { name: `* 使用默认节点 (${defaultEp.name})`, value: -1 },
-          new inquirer.Separator('  ---- 或按测速结果选择 ----'),
-          ...sorted.map((e, i) => ({
-            name: `${e.name} - ${e.latency}ms (评分:${e.score})`,
-            value: i
-          }))
-        ]
-      }]);
-      selectedEndpoint = selectedIndex === -1 ? defaultEp : sorted[selectedIndex];
-    } else {
-      console.log(chalk.red('\n⚠️  所有节点均不可达'));
-      const { proceed } = await inquirer.prompt([{
-        type: 'confirm', name: 'proceed',
-        message: '仍要使用默认节点配置吗？', default: false
-      }]);
-      if (!proceed) { console.log(chalk.gray('已取消')); return; }
-    }
-  }
+  const selectedEndpoint = await resolveEndpointSelection(args, {
+    proceedMessage: '仍要使用默认节点配置吗？'
+  });
+  if (!selectedEndpoint) return;
 
   // ---- API Key ----
   const directKey = (args['api-key'] || args.apiKey || args.key || '').toString().trim();
@@ -5319,47 +5555,22 @@ async function activateCodex(paths, args = {}) {
 // ============ 单独配置 Hermes ============
 async function activateHermes(paths, args = {}) {
   console.log(chalk.cyan.bold('\n🔧 配置 Hermes\n'));
-  const selectedModel = await promptClaudeModelSelection(args, '选择 Hermes 默认 Claude 模型:');
-
-  const shouldTest = !(args['no-test'] || args.noTest);
-  let selectedEndpoint = ENDPOINTS[0];
-
-  if (shouldTest) {
-    console.log(chalk.cyan('📡 开始测速节点...\n'));
-    const speedResult = await testAllEndpoints(ENDPOINTS, { autoFallback: true });
-    const sorted = speedResult.ranked || [];
-    if (sorted.length > 0) {
-      const defaultEp = ENDPOINTS[0];
-      const { selectedIndex } = await inquirer.prompt([{
-        type: 'list',
-        name: 'selectedIndex',
-        message: '选择节点:',
-        choices: [
-          { name: `* 使用默认节点 (${defaultEp.name})`, value: -1 },
-          new inquirer.Separator('  ---- 或按测速结果选择 ----'),
-          ...sorted.map((e, i) => ({
-            name: `${e.name} - ${e.latency}ms (评分:${e.score})`,
-            value: i
-          }))
-        ]
-      }]);
-      selectedEndpoint = selectedIndex === -1 ? defaultEp : sorted[selectedIndex];
-    } else {
-      console.log(chalk.red('\n⚠️  所有节点均不可达'));
-      const { proceed } = await inquirer.prompt([{
-        type: 'confirm', name: 'proceed',
-        message: '仍要使用默认节点配置吗？', default: false
-      }]);
-      if (!proceed) { console.log(chalk.gray('已取消')); return; }
-    }
-  }
+  const selection = await promptHermesModelSelection(args, '选择 Hermes 默认模型:');
+  const selectedModel = selection.model;
+  const selectedType = selection.type;
+  const selectedEndpoint = await resolveEndpointSelection(args, {
+    proceedMessage: '仍要使用默认节点配置吗？'
+  });
+  if (!selectedEndpoint) return;
 
   const directKey = (args['api-key'] || args.apiKey || args.key || '').toString().trim();
   let apiKey;
   if (directKey) {
     apiKey = directKey;
   } else {
-    const envKey = process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || process.env.CLAUDE_API_KEY || '';
+    const envKey = selectedType === 'codex'
+      ? (process.env.OPENAI_API_KEY || process.env.OPENAI_AUTH_TOKEN || '')
+      : (process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || process.env.CLAUDE_API_KEY || '');
     apiKey = await promptApiKey('请输入 API Key:', envKey);
   }
   if (!apiKey) { console.log(chalk.gray('已取消')); return; }
@@ -5374,15 +5585,17 @@ async function activateHermes(paths, args = {}) {
     if (!continueAnyway) { console.log(chalk.gray('已取消')); return; }
   }
 
-  const claudeBaseUrl = buildFullUrl(selectedEndpoint.url, 'claude');
+  const typeLabel = selectedType === 'codex' ? 'GPT' : 'Claude';
+  const hermesBaseUrl = buildFullUrl(selectedEndpoint.url, selectedType === 'codex' ? 'codex' : 'claude');
   const writeSpinner = ora({ text: '正在写入 Hermes 配置...', spinner: 'dots' }).start();
-  const hermesPaths = writeHermesConfig(claudeBaseUrl, apiKey, selectedModel.id);
+  const hermesPaths = writeHermesConfig(hermesBaseUrl, apiKey, selectedModel.id, { type: selectedType });
   writeSpinner.succeed('Hermes 配置写入完成');
 
   console.log(chalk.green('\n✅ Hermes 配置完成！'));
   console.log(chalk.cyan(`   Base URL: ${hermesPaths.baseUrl}`));
   console.log(chalk.gray(`   模型: ${selectedModel.name} (${selectedModel.id})`));
-  console.log(chalk.gray('   Provider: anthropic'));
+  console.log(chalk.gray(`   协议: ${typeLabel}`));
+  console.log(chalk.gray(`   Provider: ${hermesPaths.provider}`));
   console.log(chalk.gray('   API Key: 已设置'));
   console.log(chalk.gray('\n   已写入:'));
   console.log(chalk.gray(`   • ${hermesPaths.configPath}`));
@@ -5390,8 +5603,12 @@ async function activateHermes(paths, args = {}) {
   if (hermesPaths.wslConfigPath && hermesPaths.wslEnvPath) {
     console.log(chalk.gray('   • 已额外同步到 WSL ~/.hermes'));
   }
-  console.log(chalk.yellow('\n   提示: Hermes Desktop 的“测试连接”按钮当前可能仍按 /v1/models 检测；按钮不绿，不代表 runtime 不能正常对话'));
-  console.log(chalk.yellow('   建议: 重启 Hermes Desktop，或手动执行 hermes server --port 8787 验证 Hermes runtime'));
+  console.log(chalk.yellow('\n   提示: Hermes doctor 当前会固定检查官方 Anthropic /v1/models，不会读取 model.base_url；第三方 Anthropic 中转可能被误报为 invalid API key'));
+  console.log(chalk.yellow('   建议: 以 yymaxapi 的 Hermes CLI 运行时测试，或 `hermes chat -Q -q "请只回复 OK"` 的结果为准'));
+
+  if (await confirmImmediateTest(args, '是否立即测试 Hermes CLI 连接？')) {
+    await testAdditionalCliConnections(args, { only: ['hermes'] });
+  }
 }
 
 // ============ 主程序 ============
@@ -5433,6 +5650,10 @@ async function main() {
     await testConnection(paths, args);
     return;
   }
+  if (args._.includes('speed-test') || args._.includes('speedtest')) {
+    await speedTestNodes();
+    return;
+  }
 
   while (true) {
     // 显示当前状态
@@ -5459,6 +5680,7 @@ async function main() {
         new inquirer.Separator('  -- 工具 --'),
         { name: '  切换 OpenClaw 模型', value: 'switch_model' },
         { name: `  权限管理${getToolsProfileTag(paths)}`, value: 'tools_profile' },
+        { name: '  测速节点', value: 'speed_test_nodes' },
         { name: '  测试连接', value: 'test_connection' },
         { name: '  查看配置', value: 'view_config' },
         { name: '  恢复默认', value: 'restore' },
@@ -5482,6 +5704,9 @@ async function main() {
         case 'test_connection':
           await testConnection(paths, {});
           break;
+        case 'speed_test_nodes':
+          await speedTestNodes();
+          break;
         case 'switch_model':
           await switchModel(paths);
           break;
@@ -6686,6 +6911,8 @@ function testGatewayViaAgent(model, agentId = '') {
       }
       const nodeInfo = findCompatibleNode(nodeMajor);
       const env = { ...process.env, PATH: extendPathEnv(nodeInfo ? nodeInfo.path : null), NODE_NO_WARNINGS: '1' };
+      delete env.ANTHROPIC_API_KEY;
+      delete env.ANTHROPIC_AUTH_TOKEN;
       delete env.CLAUDE_API_KEY;
       delete env.OPENCLAW_CLAUDE_KEY;
       delete env.OPENCLAW_API_KEY;

package/config/API/350/212/202/347/202/271/350/256/276/347/275/256.md

@@ -155,7 +155,8 @@ npx yymaxapi@latest
 {
   "apiBaseUrl": "https://yunyi.rdzhvip.com/claude",
   "env": {
-    "ANTHROPIC_AUTH_TOKEN": "<你的云翼 API Key>"
+    "ANTHROPIC_API_KEY": "<你的云翼 API Key>",
+    "ANTHROPIC_BASE_URL": "https://yunyi.rdzhvip.com/claude"
   }
 }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yymaxapi",
-  "version": "1.0.103",
+  "version": "1.0.108",
   "description": "跨平台 OpenClaw/Clawdbot 配置管理工具 - 管理中转地址、模型切换、API Keys、测速优化",
   "main": "bin/yymaxapi.js",
   "bin": {