@adversity/coding-tool-x 3.1.0 → 3.1.1

package/src/server/services/speed-test.js

@@ -7,20 +7,21 @@
 const https = require('https');
 const http = require('http');
 const { URL } = require('url');
-const path = require('path');
-const fs = require('fs');
 const { probeModelAvailability } = require('./model-detector');
+const { getEffectiveApiKey: getClaudeEffectiveApiKey } = require('./channels');
+const { getEffectiveApiKey: getCodexEffectiveApiKey } = require('./codex-channels');
+const { getEffectiveApiKey: getGeminiEffectiveApiKey } = require('./gemini-channels');
+const { getEffectiveApiKey: getOpenCodeEffectiveApiKey } = require('./opencode-channels');
 
 // 测试结果缓存
 const testResultsCache = new Map();
 
-// Codex 请求体模板文件路径
-const CODEX_REQUEST_TEMPLATE_PATH = path.join(__dirname, 'codex-speed-test-template.json');
-
 // 超时配置（毫秒）
 const DEFAULT_TIMEOUT = 15000;
 const MIN_TIMEOUT = 5000;
 const MAX_TIMEOUT = 60000;
+const CLAUDE_CODE_BETA_HEADER = 'claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14,prompt-caching-2024-07-31';
+const ROUTE_OR_METHOD_MISMATCH_STATUS = new Set([404, 405, 501]);
 
 /**
  * 规范化超时时间
@@ -30,6 +31,203 @@ function sanitizeTimeout(timeout) {
   return Math.min(Math.max(ms, MIN_TIMEOUT), MAX_TIMEOUT);
 }
 
+/**
+ * 规范化批量测速并发度（默认小并发）
+ */
+function sanitizeBatchConcurrency(concurrency, defaultValue = 2) {
+  const value = Number(concurrency);
+  if (!Number.isFinite(value) || value <= 0) {
+    return defaultValue;
+  }
+  return Math.min(Math.max(Math.round(value), 1), 5);
+}
+
+/**
+ * 按并发限制执行异步任务，保持结果顺序与输入一致
+ */
+async function runWithConcurrencyLimit(items, concurrency, taskFn) {
+  const list = Array.isArray(items) ? items : [];
+  if (list.length === 0) return [];
+
+  const limit = sanitizeBatchConcurrency(concurrency);
+  const results = new Array(list.length);
+  let cursor = 0;
+
+  async function worker() {
+    while (true) {
+      const currentIndex = cursor;
+      cursor += 1;
+      if (currentIndex >= list.length) {
+        return;
+      }
+      results[currentIndex] = await taskFn(list[currentIndex], currentIndex);
+    }
+  }
+
+  const workers = [];
+  const workerCount = Math.min(limit, list.length);
+  for (let i = 0; i < workerCount; i += 1) {
+    workers.push(worker());
+  }
+  await Promise.all(workers);
+  return results;
+}
+
+function normalizeNonEmptyString(value) {
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  return trimmed || null;
+}
+
+function resolveExplicitModel(channel, model) {
+  return (
+    normalizeNonEmptyString(model)
+    || normalizeNonEmptyString(channel?.model)
+    || normalizeNonEmptyString(channel?.modelConfig?.model)
+  );
+}
+
+function resolveEffectiveApiKey(channel, channelType) {
+  switch (channelType) {
+    case 'codex':
+      return getCodexEffectiveApiKey(channel);
+    case 'gemini':
+      return getGeminiEffectiveApiKey(channel);
+    case 'opencode':
+      return getOpenCodeEffectiveApiKey(channel);
+    case 'claude':
+    default:
+      return getClaudeEffectiveApiKey(channel);
+  }
+}
+
+function mapStainlessOs() {
+  switch (process.platform) {
+    case 'darwin':
+      return 'MacOS';
+    case 'win32':
+      return 'Windows';
+    case 'linux':
+      return 'Linux';
+    default:
+      return `other::${process.platform}`;
+  }
+}
+
+function mapStainlessArch() {
+  switch (process.arch) {
+    case 'x64':
+      return 'x64';
+    case 'arm64':
+      return 'arm64';
+    case 'ia32':
+      return 'x86';
+    default:
+      return `other::${process.arch}`;
+  }
+}
+
+function buildGeminiNativeGeneratePath(parsedUrl, model) {
+  let pathname = parsedUrl.pathname.replace(/\/+$/, '');
+  const modelsIndex = pathname.indexOf('/models');
+  if (modelsIndex >= 0) {
+    pathname = pathname.slice(0, modelsIndex);
+  }
+
+  let apiBasePath;
+  if (!pathname || pathname === '/') {
+    apiBasePath = '/v1beta';
+  } else if (pathname.endsWith('/v1beta') || pathname.endsWith('/v1')) {
+    apiBasePath = pathname;
+  } else {
+    apiBasePath = `${pathname}/v1beta`;
+  }
+
+  return `${apiBasePath}/models/${encodeURIComponent(model)}:generateContent`;
+}
+
+function buildGeminiCliGeneratePath(parsedUrl) {
+  let pathname = parsedUrl.pathname.replace(/\/+$/, '');
+  if (!pathname || pathname === '/') {
+    return '/v1internal:generateContent';
+  }
+  if (pathname.endsWith(':streamGenerateContent')) {
+    return pathname.replace(/:streamGenerateContent$/, ':generateContent');
+  }
+  if (pathname.endsWith(':generateContent')) {
+    return pathname;
+  }
+  if (pathname.endsWith('/v1internal')) {
+    return `${pathname}:generateContent`;
+  }
+  if (pathname.endsWith('/v1')) {
+    return '/v1internal:generateContent';
+  }
+  return `${pathname}/v1internal:generateContent`;
+}
+
+function buildCodexResponsesPath(parsedUrl) {
+  let pathname = parsedUrl.pathname.replace(/\/+$/, '');
+  if (!pathname || pathname === '/') {
+    return '/responses';
+  }
+  if (pathname.endsWith('/responses') || pathname.endsWith('/v1/responses')) {
+    return pathname;
+  }
+  if (pathname.endsWith('/v1')) {
+    return `${pathname}/responses`;
+  }
+  return `${pathname}/responses`;
+}
+
+function shouldUseGeminiCliFormat(parsedUrl) {
+  const host = String(parsedUrl.hostname || '').toLowerCase();
+  const pathname = parsedUrl.pathname.replace(/\/+$/, '');
+
+  if (pathname.includes('/v1internal') || pathname.endsWith(':generateContent') || pathname.endsWith(':streamGenerateContent')) {
+    return true;
+  }
+  if (pathname.includes('/v1beta') || pathname.includes('/models/')) {
+    return false;
+  }
+  if (host.includes('cloudcode-pa.googleapis.com')) {
+    return true;
+  }
+  if (!pathname || pathname === '/') {
+    return !host.includes('generativelanguage.googleapis.com') && !host.includes('aiplatform.googleapis.com');
+  }
+  return false;
+}
+
+function extractJsonPayloads(responseData) {
+  const payloads = [];
+  const text = typeof responseData === 'string' ? responseData : String(responseData || '');
+  if (!text.trim()) {
+    return payloads;
+  }
+
+  try {
+    payloads.push(JSON.parse(text));
+  } catch {
+    // ignore and continue parsing SSE fragments
+  }
+
+  const lines = text.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('data:')) continue;
+    const rawData = trimmed.slice(5).trim();
+    if (!rawData || rawData === '[DONE]') continue;
+    try {
+      payloads.push(JSON.parse(rawData));
+    } catch {
+      // ignore invalid SSE fragment
+    }
+  }
+
+  return payloads;
+}
+
 /**
  * 测试单个渠道的连接速度和 API 功能
  * @param {Object} channel - 渠道配置
@@ -74,9 +272,31 @@ async function testChannelSpeed(channel, timeout = DEFAULT_TIMEOUT, channelType
       };
     }
 
+    const effectiveApiKey = resolveEffectiveApiKey(channel, channelType);
+    if (!effectiveApiKey) {
+      return {
+        channelId: channel.id,
+        channelName: channel.name,
+        success: false,
+        networkOk: false,
+        apiOk: false,
+        error: 'API Key 未配置',
+        latency: null,
+        statusCode: null,
+        testedAt: Date.now()
+      };
+    }
+
     // 直接测试 API 功能（发送测试消息）
     // 不再单独测试网络连通性，因为直接 GET base_url 可能返回 404
-    const apiResult = await testAPIFunctionality(testUrl, channel.apiKey, sanitizedTimeout, channelType, channel.model, channel);
+    const apiResult = await testAPIFunctionality(
+      testUrl,
+      effectiveApiKey,
+      sanitizedTimeout,
+      channelType,
+      channel.model,
+      channel
+    );
 
     const success = apiResult.success;
     const networkOk = apiResult.latency !== null; // 如果有延迟数据，说明网络是通的
@@ -90,7 +310,7 @@ async function testChannelSpeed(channel, timeout = DEFAULT_TIMEOUT, channelType
       apiOk: success,
       statusCode: apiResult.statusCode || null,
       error: success ? null : (apiResult.error || '测试失败'),
-      latency: apiResult.latency || null, // 无论成功失败都保留延迟数据
+      latency: apiResult.latency ?? null, // 无论成功失败都保留延迟数据（保留 0ms）
       testedAt: Date.now(),
       testedModel: apiResult.testedModel,
       availableModels: apiResult.availableModels,
@@ -199,220 +419,259 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
   // Probe model availability if channel is provided
   let modelProbe = null;
   if (channel) {
-    // Check if speedTestModel is explicitly configured
-    if (channel.speedTestModel) {
+    const configuredSpeedTestModel = normalizeNonEmptyString(channel.speedTestModel);
+    const explicitModel = resolveExplicitModel(channel, model);
+
+    // 优先使用 speedTestModel，避免测速时额外探测
+    if (configuredSpeedTestModel) {
       // Use the explicitly configured model for speed testing
       modelProbe = {
-        preferredTestModel: channel.speedTestModel,
-        availableModels: [channel.speedTestModel],
-        cached: false
+        preferredTestModel: configuredSpeedTestModel,
+        availableModels: [configuredSpeedTestModel],
+        cached: false,
+        method: 'configured'
       };
-      console.log(`[SpeedTest] Using configured speedTestModel: ${channel.speedTestModel}`);
+      console.log(`[SpeedTest] Using configured speedTestModel: ${configuredSpeedTestModel}`);
+    } else if (explicitModel) {
+      modelProbe = {
+        preferredTestModel: explicitModel,
+        availableModels: [explicitModel],
+        cached: false,
+        method: 'configured'
+      };
+      console.log(`[SpeedTest] Using explicit model: ${explicitModel}`);
     } else {
       // Fall back to auto-detection
       try {
-        modelProbe = await probeModelAvailability(channel, channelType);
+        modelProbe = await probeModelAvailability(channel, channelType, { stopOnFirstAvailable: true });
       } catch (error) {
         console.error('[SpeedTest] Model detection failed:', error.message);
       }
     }
   }
 
-  return new Promise((resolve) => {
-    const startTime = Date.now();
-    const parsedUrl = new URL(baseUrl);
-    const isHttps = parsedUrl.protocol === 'https:';
-    const httpModule = isHttps ? https : http;
-
-    // Helper to create result object with model info
-    const createResult = (result) => ({
-      ...result,
-      testedModel: testModel,
-      availableModels: modelProbe?.availableModels,
-      modelDetectionMethod: modelProbe?.cached ? 'cached' : 'probed'
-    });
+  const parsedUrl = new URL(baseUrl);
+  const isHttps = parsedUrl.protocol === 'https:';
+  const httpModule = isHttps ? https : http;
+
+  // 根据渠道类型确定 API 路径和请求格式
+  let testModel = null;
+  let primaryRequestConfig = null;
+  let fallbackRequestConfig = null;
+
+  // Helper to create result object with model info
+  const createResult = (result) => ({
+    ...result,
+    testedModel: testModel,
+    availableModels: modelProbe?.availableModels,
+    modelDetectionMethod: modelProbe?.method || (modelProbe?.cached ? 'cached' : 'probed')
+  });
 
-    // 根据渠道类型确定 API 路径和请求格式
-    let apiPath;
-    let requestBody;
-    let headers;
-    let testModel = null; // Track which model is actually being tested
-
-    // Claude 渠道使用 Anthropic 格式
-    if (channelType === 'claude') {
-      // Anthropic Messages API - 模拟 Claude Code 请求格式
-      apiPath = parsedUrl.pathname.replace(/\/$/, '');
-      if (!apiPath.endsWith('/messages')) {
-        apiPath = apiPath + (apiPath.endsWith('/v1') ? '/messages' : '/v1/messages');
+  const parseErrorMessage = (responseData) => {
+    const payloads = extractJsonPayloads(responseData);
+    for (const payload of payloads) {
+      const message = payload?.error?.message || payload?.message || payload?.detail || payload?.error_description;
+      if (message) return message;
+    }
+    return null;
+  };
+
+  const UNEXPECTED_ERROR_PATTERNS = [
+    /unexpected/i,
+    /internal.*error/i,
+    /something.*went.*wrong/i,
+    /service.*unavailable/i,
+    /temporarily.*unavailable/i,
+    /try.*again.*later/i,
+    /server.*error/i,
+    /bad.*gateway/i,
+    /gateway.*timeout/i
+  ];
+
+  function containsUnexpectedError(responseBody) {
+    const payloads = extractJsonPayloads(responseBody);
+    for (const payload of payloads) {
+      if (payload?.error) {
+        return { hasError: true, message: payload.error.message || payload.error };
+      }
+      const message = payload?.message || payload?.detail || payload?.error_description || '';
+      for (const pattern of UNEXPECTED_ERROR_PATTERNS) {
+        if (pattern.test(message)) {
+          return { hasError: true, message };
+        }
       }
-      // 添加 ?beta=true 查询参数
-      apiPath += '?beta=true';
-
-      // 使用 Claude Code 的请求格式
-      // user_id 必须符合特定格式: user_xxx_account__session_xxx
-      // 优先使用模型检测结果，否则回退到 claude-sonnet-4-20250514
-      testModel = modelProbe?.preferredTestModel || 'claude-sonnet-4-20250514';
-      const sessionId = Math.random().toString(36).substring(2, 15);
-      requestBody = JSON.stringify({
+    }
+    return { hasError: false };
+  }
+
+  if (channelType === 'claude') {
+    // Anthropic Messages API - 模拟 Claude Code 请求格式
+    let apiPath = parsedUrl.pathname.replace(/\/$/, '');
+    if (!apiPath.endsWith('/messages')) {
+      apiPath = apiPath + (apiPath.endsWith('/v1') ? '/messages' : '/v1/messages');
+    }
+    apiPath += '?beta=true';
+
+    testModel = modelProbe?.preferredTestModel || normalizeNonEmptyString(model) || 'claude-sonnet-4-20250514';
+    const sessionId = Math.random().toString(36).substring(2, 15);
+    primaryRequestConfig = {
+      apiPath,
+      requestBody: JSON.stringify({
         model: testModel,
         max_tokens: 1,
-        stream: true,
-        messages: [{ role: 'user', content: [{ type: 'text', text: 'Hi' }] }],
+        stream: false,
+        messages: [{ role: 'user', content: [{ type: 'text', text: 'ping' }] }],
         system: [{ type: 'text', text: "You are Claude Code, Anthropic's official CLI for Claude." }],
         metadata: { user_id: `user_0000000000000000000000000000000000000000000000000000000000000000_account__session_${sessionId}` }
-      });
-
-      headers = {
+      }),
+      headers: {
         'x-api-key': apiKey || '',
         'Authorization': `Bearer ${apiKey || ''}`,
         'anthropic-version': '2023-06-01',
-        'anthropic-beta': 'claude-code-20250219,interleaved-thinking-2025-05-14',
+        'anthropic-beta': CLAUDE_CODE_BETA_HEADER,
         'anthropic-dangerous-direct-browser-access': 'true',
         'x-app': 'cli',
+        'x-stainless-helper-method': 'stream',
+        'x-stainless-retry-count': '0',
+        'x-stainless-runtime-version': 'v24.3.0',
+        'x-stainless-package-version': '0.74.0',
         'x-stainless-lang': 'js',
         'x-stainless-runtime': 'node',
+        'x-stainless-arch': mapStainlessArch(),
+        'x-stainless-os': mapStainlessOs(),
+        'x-stainless-timeout': '600',
+        'Accept': 'application/json',
+        'Accept-Encoding': 'gzip, deflate, br, zstd',
+        'Connection': 'keep-alive',
         'Content-Type': 'application/json',
-        'User-Agent': 'claude-cli/2.0.53 (external, cli)'
-      };
-    } else if (channelType === 'codex') {
-      // Codex 使用 OpenAI Responses API 格式
-      // 路径: /v1/responses
-      apiPath = parsedUrl.pathname.replace(/\/$/, '');
-      if (!apiPath.endsWith('/responses')) {
-        apiPath = apiPath + (apiPath.endsWith('/v1') ? '/responses' : '/v1/responses');
-      }
-      // 从模板文件加载完整的 Codex 请求格式
-      try {
-        const template = JSON.parse(fs.readFileSync(CODEX_REQUEST_TEMPLATE_PATH, 'utf-8'));
-        // 生成新的 prompt_cache_key
-        template.prompt_cache_key = `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
-        // 使用模型检测结果更新模型（如果有）
-        if (modelProbe?.preferredTestModel) {
-          template.model = modelProbe.preferredTestModel;
-        }
-        testModel = template.model; // Track the model being used
-        requestBody = JSON.stringify(template);
-      } catch (err) {
-        console.error('[SpeedTest] Failed to load Codex template:', err.message);
-        // 降级使用简化版本（可能会失败）
-        testModel = modelProbe?.preferredTestModel || 'gpt-5-codex';
-        requestBody = JSON.stringify({
-          model: testModel,
-          instructions: 'You are Codex.',
-          input: [{ type: 'message', role: 'user', content: [{ type: 'input_text', text: 'ping' }] }],
-          max_output_tokens: 1,
-          stream: false,
-          store: false
-        });
-      }
-      headers = {
+        'User-Agent': 'claude-cli/2.1.44 (external, sdk-cli)'
+      },
+      isStreamingResponse: false
+    };
+  } else if (channelType === 'codex') {
+    const apiPath = buildCodexResponsesPath(parsedUrl);
+    testModel = modelProbe?.preferredTestModel || normalizeNonEmptyString(model) || 'gpt-5-codex';
+    const codexSessionId = `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+
+    const baseBody = {
+      model: testModel,
+      instructions: 'You are Codex.',
+      input: [{ type: 'message', role: 'user', content: [{ type: 'input_text', text: 'ping' }] }],
+      store: false,
+      prompt_cache_key: codexSessionId
+    };
+
+    primaryRequestConfig = {
+      apiPath,
+      requestBody: JSON.stringify({ ...baseBody, stream: false }),
+      headers: {
         'Authorization': `Bearer ${apiKey || ''}`,
+        'Accept': 'application/json',
+        'Connection': 'Keep-Alive',
+        'Version': '0.101.0',
+        'Session_id': codexSessionId,
+        'Originator': 'codex_cli_rs',
         'Content-Type': 'application/json',
-        'User-Agent': 'codex_cli_rs/0.65.0',
+        'User-Agent': 'codex_cli_rs/0.101.0 (Mac OS 26.0.1; arm64) Apple_Terminal/464',
         'openai-beta': 'responses=experimental'
-      };
-    } else if (channelType === 'gemini') {
-      // Gemini 也使用 OpenAI 兼容格式
-      apiPath = parsedUrl.pathname.replace(/\/$/, '');
-      if (!apiPath.endsWith('/chat/completions')) {
-        apiPath = apiPath + (apiPath.endsWith('/v1') ? '/chat/completions' : '/v1/chat/completions');
-      }
-      // 优先使用模型检测结果，其次使用渠道配置的模型，最后默认使用 gemini-2.5-pro
-      testModel = modelProbe?.preferredTestModel || model || 'gemini-2.5-pro';
-      requestBody = JSON.stringify({
+      },
+      isStreamingResponse: false
+    };
+
+    fallbackRequestConfig = {
+      apiPath,
+      requestBody: JSON.stringify({ ...baseBody, stream: true }),
+      headers: {
+        ...primaryRequestConfig.headers,
+        'Accept': 'text/event-stream'
+      },
+      isStreamingResponse: true
+    };
+  } else if (channelType === 'gemini') {
+    testModel = modelProbe?.preferredTestModel || normalizeNonEmptyString(model) || 'gemini-2.5-pro';
+    const useCliFormat = shouldUseGeminiCliFormat(parsedUrl);
+
+    const cliRequestConfig = {
+      apiPath: buildGeminiCliGeneratePath(parsedUrl),
+      requestBody: JSON.stringify({
+        project: '',
         model: testModel,
-        max_tokens: 1,
-        messages: [{ role: 'user', content: 'Hi' }]
-      });
-      headers = {
+        request: {
+          contents: [{ role: 'user', parts: [{ text: 'ping' }] }],
+          generationConfig: { maxOutputTokens: 1, temperature: 0 }
+        }
+      }),
+      headers: {
         'Authorization': `Bearer ${apiKey || ''}`,
+        'x-goog-api-key': apiKey || '',
+        'Accept': 'application/json',
         'Content-Type': 'application/json',
-        'User-Agent': 'Coding-Tool-SpeedTest/1.0'
-      };
-    } else {
-      // 默认使用 OpenAI 格式
-      apiPath = parsedUrl.pathname.replace(/\/$/, '');
-      if (!apiPath.endsWith('/chat/completions')) {
-        apiPath = apiPath + (apiPath.endsWith('/v1') ? '/chat/completions' : '/v1/chat/completions');
-      }
-      requestBody = JSON.stringify({
+        'User-Agent': 'google-api-nodejs-client/9.15.1',
+        'X-Goog-Api-Client': 'gl-node/22.17.0',
+        'Client-Metadata': 'ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI'
+      },
+      isStreamingResponse: false
+    };
+
+    const nativeRequestConfig = {
+      apiPath: buildGeminiNativeGeneratePath(parsedUrl, testModel),
+      requestBody: JSON.stringify({
+        contents: [{ role: 'user', parts: [{ text: 'ping' }] }],
+        generationConfig: { maxOutputTokens: 1, temperature: 0 }
+      }),
+      headers: {
+        'Authorization': `Bearer ${apiKey || ''}`,
+        'x-goog-api-key': apiKey || '',
+        'Accept': 'application/json',
+        'Content-Type': 'application/json',
+        'User-Agent': 'google-genai-sdk/0.8.0'
+      },
+      isStreamingResponse: false
+    };
+
+    primaryRequestConfig = useCliFormat ? cliRequestConfig : nativeRequestConfig;
+    fallbackRequestConfig = useCliFormat ? nativeRequestConfig : cliRequestConfig;
+  } else {
+    let apiPath = parsedUrl.pathname.replace(/\/$/, '');
+    if (!apiPath.endsWith('/chat/completions')) {
+      apiPath = apiPath + (apiPath.endsWith('/v1') ? '/chat/completions' : '/v1/chat/completions');
+    }
+    primaryRequestConfig = {
+      apiPath,
+      requestBody: JSON.stringify({
         model: 'gpt-4o-mini',
         max_tokens: 1,
         messages: [{ role: 'user', content: 'Hi' }]
-      });
-      headers = {
+      }),
+      headers: {
         'Authorization': `Bearer ${apiKey || ''}`,
         'Content-Type': 'application/json',
         'User-Agent': 'Coding-Tool-SpeedTest/1.0'
-      };
-    }
+      },
+      isStreamingResponse: false
+    };
+  }
 
+  const executeRequest = (requestConfig) => new Promise((resolve) => {
+    const startTime = Date.now();
     const options = {
       hostname: parsedUrl.hostname,
       port: parsedUrl.port || (isHttps ? 443 : 80),
-      path: apiPath,
+      path: requestConfig.apiPath,
       method: 'POST',
       timeout,
-      headers
+      headers: requestConfig.headers
     };
 
     const req = httpModule.request(options, (res) => {
       let data = '';
       let resolved = false;
-      const isStreamingResponse = channelType === 'codex'; // Codex 使用流式响应
-
-      // 解析响应体中的错误信息
-      const parseErrorMessage = (responseData) => {
-        try {
-          const errData = JSON.parse(responseData);
-          return errData.error?.message || errData.message || errData.detail || null;
-        } catch {
-          return null;
-        }
-      };
-
-      const UNEXPECTED_ERROR_PATTERNS = [
-        /unexpected/i,
-        /internal.*error/i,
-        /something.*went.*wrong/i,
-        /service.*unavailable/i,
-        /temporarily.*unavailable/i,
-        /try.*again.*later/i,
-        /server.*error/i,
-        /bad.*gateway/i,
-        /gateway.*timeout/i
-      ];
-
-      function containsUnexpectedError(responseBody) {
-        try {
-          const data = typeof responseBody === 'string' ? JSON.parse(responseBody) : responseBody;
-
-          // Check for explicit error field
-          if (data.error) {
-            return { hasError: true, message: data.error.message || data.error };
-          }
-
-          // Check message patterns
-          const message = data.message || data.detail || data.error_description || '';
-          for (const pattern of UNEXPECTED_ERROR_PATTERNS) {
-            if (pattern.test(message)) {
-              return { hasError: true, message };
-            }
-          }
-
-          return { hasError: false };
-        } catch {
-          return { hasError: false };
-        }
-      }
 
       res.on('data', chunk => {
         data += chunk;
         const chunkStr = chunk.toString();
 
-        // 对于流式响应（Codex），在收到第一个有效事件时立即返回成功
-        if (isStreamingResponse && !resolved && res.statusCode >= 200 && res.statusCode < 300) {
-          // 检查是否收到了 response.created 或 response.in_progress 事件
+        if (requestConfig.isStreamingResponse && !resolved && res.statusCode >= 200 && res.statusCode < 300) {
           if (chunkStr.includes('response.created') || chunkStr.includes('response.in_progress')) {
             resolved = true;
             const latency = Date.now() - startTime;
@@ -423,8 +682,7 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
               error: null,
               statusCode: res.statusCode
             }));
-          } else if (chunkStr.includes('"detail"') || chunkStr.includes('"error"')) {
-            // 流式响应中的错误 - 使用新的错误检测函数
+          } else if (chunkStr.includes('"detail"') || chunkStr.includes('"error"') || chunkStr.includes('data:')) {
             const errorCheck = containsUnexpectedError(chunkStr);
             if (errorCheck.hasError) {
               resolved = true;
@@ -442,13 +700,10 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
       });
 
       res.on('end', () => {
-        if (resolved) return; // 已经处理过了
+        if (resolved) return;
 
         const latency = Date.now() - startTime;
-
-        // 严格判断：只有 2xx 且没有错误信息才算成功
         if (res.statusCode >= 200 && res.statusCode < 300) {
-          // 使用新的错误检测函数
           const errorCheck = containsUnexpectedError(data);
           if (errorCheck.hasError) {
             resolve(createResult({
@@ -458,7 +713,6 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
               statusCode: res.statusCode
             }));
           } else {
-            // 真正的成功响应
             resolve(createResult({
               success: true,
               latency,
@@ -481,7 +735,6 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
             statusCode: res.statusCode
           }));
         } else if (res.statusCode === 429) {
-          // 请求过多 - 标记为失败
           const errMsg = parseErrorMessage(data) || '请求过多，服务限流中';
           resolve(createResult({
             success: false,
@@ -490,7 +743,6 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
             statusCode: res.statusCode
           }));
         } else if (res.statusCode === 503 || res.statusCode === 529) {
-          // 服务暂时不可用/过载 - 标记为失败
           const errMsg = parseErrorMessage(data) || (res.statusCode === 503 ? '服务暂时不可用' : '服务过载');
           resolve(createResult({
             success: false,
@@ -506,7 +758,6 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
             statusCode: res.statusCode
           }));
         } else if (res.statusCode === 400) {
-          // 请求参数错误
           const errMsg = parseErrorMessage(data) || '请求参数错误';
           resolve(createResult({
             success: false,
@@ -515,7 +766,6 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
             statusCode: res.statusCode
           }));
         } else if (res.statusCode >= 500) {
-          // 5xx 服务器错误
           const errMsg = parseErrorMessage(data) || `服务器错误 (${res.statusCode})`;
           resolve(createResult({
             success: false,
@@ -524,7 +774,6 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
             statusCode: res.statusCode
           }));
         } else {
-          // 其他错误
           const errMsg = parseErrorMessage(data) || `HTTP ${res.statusCode}`;
           resolve(createResult({
             success: false,
@@ -553,9 +802,29 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
       }));
     });
 
-    req.write(requestBody);
+    req.write(requestConfig.requestBody);
     req.end();
   });
+
+  const primaryResult = await executeRequest(primaryRequestConfig);
+  if (primaryResult.success || !fallbackRequestConfig) {
+    return primaryResult;
+  }
+
+  if (channelType === 'gemini' && ROUTE_OR_METHOD_MISMATCH_STATUS.has(primaryResult.statusCode)) {
+    return executeRequest(fallbackRequestConfig);
+  }
+
+  if (channelType === 'codex') {
+    const codexError = String(primaryResult.error || '').toLowerCase();
+    const shouldRetryWithStreaming = ROUTE_OR_METHOD_MISMATCH_STATUS.has(primaryResult.statusCode)
+      || (primaryResult.statusCode === 400 && (codexError.includes('stream') || codexError.includes('event-stream') || codexError.includes('sse')));
+    if (shouldRetryWithStreaming) {
+      return executeRequest(fallbackRequestConfig);
+    }
+  }
+
+  return primaryResult;
 }
 
 /**
@@ -565,16 +834,22 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
  * @param {string} channelType - 渠道类型：'claude' | 'codex' | 'gemini'
  * @returns {Promise<Array>} 测试结果列表
  */
-async function testMultipleChannels(channels, timeout = DEFAULT_TIMEOUT, channelType = 'claude') {
-  const results = await Promise.all(
-    channels.map(channel => testChannelSpeed(channel, timeout, channelType))
+async function testMultipleChannels(channels, timeout = DEFAULT_TIMEOUT, channelType = 'claude', concurrency = 2) {
+  const results = await runWithConcurrencyLimit(
+    channels,
+    concurrency,
+    channel => testChannelSpeed(channel, timeout, channelType)
   );
 
   // 按延迟排序（成功的在前，按延迟升序）
   results.sort((a, b) => {
     if (a.success && !b.success) return -1;
     if (!a.success && b.success) return 1;
-    if (a.success && b.success) return (a.latency || Infinity) - (b.latency || Infinity);
+    if (a.success && b.success) {
+      const aLatency = (a.latency === null || a.latency === undefined) ? Infinity : a.latency;
+      const bLatency = (b.latency === null || b.latency === undefined) ? Infinity : b.latency;
+      return aLatency - bLatency;
+    }
     return 0;
   });
 
@@ -608,7 +883,8 @@ function clearCache() {
  * @returns {string} 等级：excellent/good/fair/poor
  */
 function getLatencyLevel(latency) {
-  if (!latency) return 'unknown';
+  if (latency === null || latency === undefined) return 'unknown';
+  if (!Number.isFinite(Number(latency))) return 'unknown';
   if (latency < 300) return 'excellent';   // < 300ms 优秀
   if (latency < 500) return 'good';        // < 500ms 良好
   if (latency < 800) return 'fair';        // < 800ms 一般
@@ -620,5 +896,7 @@ module.exports = {
   testMultipleChannels,
   getCachedResult,
   clearCache,
-  getLatencyLevel
+  getLatencyLevel,
+  sanitizeBatchConcurrency,
+  runWithConcurrencyLimit
 };