@adversity/coding-tool-x 3.1.0 → 3.1.2

package/src/server/services/model-detector.js

@@ -10,37 +10,107 @@ const https = require('https');
 const http = require('http');
 const { URL } = require('url');
 const crypto = require('crypto');
+const zlib = require('zlib');
+const { loadConfig } = require('../../config/loader');
 
-// Model priority by channel type
+// 内置模型优先级（当配置缺失时兜底）
 const MODEL_PRIORITY = {
   claude: [
+    'claude-opus-4-6',
+    'claude-sonnet-4-6',
     'claude-opus-4-5-20251101',
     'claude-sonnet-4-5-20250929',
-    'claude-haiku-4-5-20251001',
-    'claude-sonnet-4-20250514',
-    'claude-opus-4-20250514'
+    'claude-haiku-4-5-20251001'
   ],
   codex: [
     'gpt-5.2-codex',
     'gpt-5.1-codex-max',
-    'gpt-5.1-codex-mini',
     'gpt-5.1-codex',
+    'gpt-5.1-codex-mini',
     'gpt-5-codex',
     'gpt-5.2',
     'gpt-5.1',
     'gpt-5'
   ],
   gemini: [
-    'gemini-3-pro',
-    'gemini-3-flash',
-    'gemini-3-deep-think',
+    'gemini-3-pro-preview',
+    'gemini-3-flash-preview',
     'gemini-2.5-pro',
-    'gemini-2.5-flash'
+    'gemini-2.5-flash',
+    'gemini-2.5-flash-lite'
   ]
 };
 // openai_compatible 复用 codex 的模型列表
 MODEL_PRIORITY.openai_compatible = MODEL_PRIORITY.codex;
 
+function normalizeModelToolType(type) {
+  const value = String(type || '').trim().toLowerCase();
+  if (value === 'openai_compatible') return 'codex';
+  if (value === 'claude' || value === 'codex' || value === 'gemini' || value === 'opencode') {
+    return value;
+  }
+  return '';
+}
+
+/**
+ * 获取模型优先级列表（优先读取用户配置的 defaultModels）
+ * @param {string} channelType - 渠道类型
+ * @param {Object} options - 可选参数
+ * @param {string} options.toolType - 显式工具类型（claude/codex/gemini/opencode）
+ * @returns {string[]}
+ */
+function getModelPriority(channelType, options = {}) {
+  const preferredToolType = normalizeModelToolType(options.toolType);
+  const normalizedChannelType = normalizeModelToolType(channelType);
+  const candidateTypes = [];
+
+  if (preferredToolType) {
+    candidateTypes.push(preferredToolType);
+  }
+  if (normalizedChannelType && !candidateTypes.includes(normalizedChannelType)) {
+    candidateTypes.push(normalizedChannelType);
+  }
+  if (String(channelType || '').trim().toLowerCase() === 'openai_compatible' && !candidateTypes.includes('openai_compatible')) {
+    candidateTypes.push('openai_compatible');
+  }
+
+  try {
+    const config = loadConfig();
+    const defaultModels = config?.defaultModels || {};
+    for (const toolType of candidateTypes) {
+      const models = defaultModels[toolType];
+      if (Array.isArray(models) && models.length > 0) {
+        return normalizeModelCandidates(models);
+      }
+    }
+  } catch (error) {
+    console.warn(`[ModelDetector] Failed to load default models config: ${error.message}`);
+  }
+
+  return [];
+}
+
+function getModelDiscoveryConfig() {
+  try {
+    const config = loadConfig();
+    return {
+      useV1ModelsEndpoint: config?.modelDiscovery?.useV1ModelsEndpoint === true
+    };
+  } catch (error) {
+    console.warn(`[ModelDetector] Failed to load modelDiscovery config: ${error.message}`);
+    return {
+      useV1ModelsEndpoint: false
+    };
+  }
+}
+
+function shouldUseV1ModelsEndpoint(options = {}) {
+  if (typeof options.useV1ModelsEndpoint === 'boolean') {
+    return options.useV1ModelsEndpoint;
+  }
+  return getModelDiscoveryConfig().useV1ModelsEndpoint;
+}
+
 const PROVIDER_CAPABILITIES = {
   claude: {
     supportsModelList: false,
@@ -121,6 +191,8 @@ const MODEL_ALIASES = {
   'claude-3-haiku': 'claude-3-5-haiku-20241022',
   'claude-sonnet-4': 'claude-sonnet-4-20250514',
   'claude-4-sonnet': 'claude-sonnet-4-20250514',
+  'claude-sonnet-4-6': 'claude-sonnet-4-6',
+  'claude-4-6-sonnet': 'claude-sonnet-4-6',
   'claude-sonnet-4-5': 'claude-sonnet-4-5-20250929',
   'claude-4-5-sonnet': 'claude-sonnet-4-5-20250929',
   'claude-opus-4': 'claude-opus-4-20250514',
@@ -145,8 +217,31 @@ const MODEL_ALIASES = {
   'gemini-2-5-pro': 'gemini-2.5-pro'
 };
 
-const CACHE_DURATION_MS = 5 * 60 * 1000; // 5 minutes
 const TEST_TIMEOUT_MS = 10000; // 10 seconds per model test
+const CLAUDE_CODE_BETA_HEADER = 'claude-code-20250219,interleaved-thinking-2025-05-14';
+
+const MODEL_UNAVAILABLE_HINTS = [
+  'not found',
+  'does not exist',
+  'invalid model',
+  'unsupported model',
+  'not supported',
+  'model unavailable',
+  'deprecated',
+  'decommission',
+  'retired',
+  'offline',
+  'unknown model',
+  '下线',
+  '已下线',
+  '已停用',
+  '已废弃',
+  '已淘汰',
+  '模型不存在',
+  '无效模型',
+  '模型不可用',
+  '请切换'
+];
 
 /**
  * Generate realistic User-Agent strings that mimic official SDKs
@@ -205,11 +300,375 @@ function buildRequestHeaders(channelType, channel) {
   return headers;
 }
 
+function buildOpenAiCompatibleUrl(baseUrl, endpoint) {
+  const trimmed = String(baseUrl || '').trim().replace(/\/+$/, '');
+  if (!trimmed) {
+    throw new Error('Invalid baseUrl');
+  }
+
+  const normalizedEndpoint = String(endpoint || '').startsWith('/')
+    ? String(endpoint)
+    : `/${endpoint}`;
+
+  if (trimmed.endsWith(normalizedEndpoint)) {
+    return trimmed;
+  }
+
+  const endpointWithoutV1 = normalizedEndpoint.startsWith('/v1/')
+    ? normalizedEndpoint.slice(3)
+    : normalizedEndpoint;
+
+  if (trimmed.endsWith(endpointWithoutV1)) {
+    return trimmed;
+  }
+
+  if (trimmed.endsWith('/v1') && normalizedEndpoint.startsWith('/v1/')) {
+    return `${trimmed}${normalizedEndpoint.slice(3)}`;
+  }
+
+  return `${trimmed}${normalizedEndpoint}`;
+}
+
+function buildClaudeMessagesUrl(baseUrl, options = {}) {
+  const withBeta = options.withBeta !== false;
+  const parsed = new URL(String(baseUrl || '').trim());
+  let pathname = parsed.pathname.replace(/\/+$/, '');
+
+  if (!pathname || pathname === '/') {
+    pathname = '/v1/messages';
+  } else if (pathname.endsWith('/messages')) {
+    // noop
+  } else if (pathname.endsWith('/v1')) {
+    pathname = `${pathname}/messages`;
+  } else {
+    pathname = `${pathname}/v1/messages`;
+  }
+
+  parsed.pathname = pathname;
+  if (withBeta) {
+    parsed.searchParams.set('beta', 'true');
+  }
+  return parsed.toString();
+}
+
+function buildGeminiGenerateContentUrl(baseUrl, model, apiKey = '') {
+  const modelName = String(model || '').trim();
+  if (!modelName) {
+    throw new Error('Model is required for Gemini probe');
+  }
+
+  const parsed = new URL(String(baseUrl || '').trim());
+  let pathname = parsed.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`;
+  }
+
+  parsed.pathname = `${apiBasePath}/models/${encodeURIComponent(modelName)}:generateContent`;
+  if (apiKey) {
+    parsed.searchParams.set('key', apiKey);
+  }
+  return parsed.toString();
+}
+
+function buildClaudeProbePayload(model, options = {}) {
+  const includeSystem = options.includeSystem === true;
+  const systemAsArray = options.systemAsArray === true;
+  const includeMetadata = options.includeMetadata === true;
+  const sessionId = Math.random().toString(36).substring(2, 15);
+
+  const payload = {
+    model,
+    max_tokens: 1,
+    stream: false,
+    messages: [{ role: 'user', content: [{ type: 'text', text: 'ping' }] }]
+  };
+
+  if (includeSystem) {
+    const systemPrompt = "You are Claude Code, Anthropic's official CLI for Claude.";
+    payload.system = systemAsArray
+      ? [{ type: 'text', text: systemPrompt }]
+      : systemPrompt;
+  }
+
+  if (includeMetadata) {
+    payload.metadata = {
+      user_id: `user_0000000000000000000000000000000000000000000000000000000000000000_account__session_${sessionId}`
+    };
+  }
+
+  return JSON.stringify(payload);
+}
+
+function createClaudeProbeAttempts(channel, model) {
+  const apiKey = channel.apiKey || '';
+  const commonHeaders = {
+    ...buildRequestHeaders('claude', channel),
+    'Content-Type': 'application/json',
+    'x-api-key': apiKey,
+    'Authorization': `Bearer ${apiKey}`,
+    'anthropic-version': '2023-06-01',
+    'anthropic-beta': CLAUDE_CODE_BETA_HEADER,
+    'Accept-Encoding': 'gzip, deflate, br',
+    'User-Agent': 'claude-cli/2.0.53 (external, cli)'
+  };
+
+  const legacyBody = buildClaudeProbePayload(model, {
+    includeSystem: true,
+    systemAsArray: true,
+    includeMetadata: true
+  });
+
+  return [
+    {
+      label: 'claude-code-legacy-beta',
+      url: buildClaudeMessagesUrl(channel.baseUrl, { withBeta: true }),
+      body: legacyBody,
+      headers: {
+        ...commonHeaders,
+        'anthropic-dangerous-direct-browser-access': 'true',
+        'x-app': 'cli',
+        'x-stainless-lang': 'js',
+        'x-stainless-runtime': 'node'
+      }
+    }
+  ];
+}
+
+function createCodexProbeAttempts(channel, model) {
+  const apiKey = channel.apiKey || '';
+  const commonHeaders = {
+    ...buildRequestHeaders('codex', channel),
+    'Content-Type': 'application/json',
+    'Authorization': `Bearer ${apiKey}`,
+    'User-Agent': 'codex_cli_rs/0.65.0'
+  };
+
+  const responsesBody = JSON.stringify({
+    model,
+    instructions: 'You are Codex.',
+    input: [{ type: 'message', role: 'user', content: [{ type: 'input_text', text: 'ping' }] }],
+    max_output_tokens: 1,
+    stream: false,
+    store: false
+  });
+
+  return [
+    {
+      label: 'codex-responses',
+      url: buildOpenAiCompatibleUrl(channel.baseUrl, '/v1/responses'),
+      body: responsesBody,
+      headers: {
+        ...commonHeaders,
+        'openai-beta': 'responses=experimental'
+      }
+    }
+  ];
+}
+
+function createGeminiProbeAttempt(channel, model) {
+  const apiKey = channel.apiKey || '';
+  const body = JSON.stringify({
+    contents: [{ role: 'user', parts: [{ text: 'test' }] }],
+    generationConfig: { maxOutputTokens: 1, temperature: 0 }
+  });
+
+  return {
+    label: 'gemini-generate-content',
+    url: buildGeminiGenerateContentUrl(channel.baseUrl, model, apiKey),
+    body,
+    headers: {
+      ...buildRequestHeaders('gemini', channel),
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+      'x-goog-api-key': apiKey,
+      'User-Agent': 'google-genai-sdk/0.8.0'
+    }
+  };
+}
+
+function buildProbeAttempts(channel, channelType, model) {
+  const normalizedType = String(channelType || '').trim().toLowerCase();
+  if (normalizedType === 'claude') {
+    return createClaudeProbeAttempts(channel, model);
+  }
+  if (normalizedType === 'codex' || normalizedType === 'openai_compatible') {
+    return createCodexProbeAttempts(channel, model);
+  }
+  if (normalizedType === 'gemini') {
+    return [createGeminiProbeAttempt(channel, model)];
+  }
+  return [];
+}
+
+function extractProbeErrorMessage(responseBody) {
+  const fallback = String(responseBody || '');
+  try {
+    const response = JSON.parse(responseBody || '{}');
+    if (typeof response === 'string') return response;
+    if (typeof response?.error?.message === 'string') return response.error.message;
+    if (typeof response?.error === 'string') return response.error;
+    if (typeof response?.message === 'string') return response.message;
+    if (typeof response?.detail === 'string') return response.detail;
+    return fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+function classifyProbeResult(statusCode, responseBody, model) {
+  if (statusCode >= 200 && statusCode < 300) {
+    return 'available';
+  }
+
+  const errorMsg = extractProbeErrorMessage(responseBody).toLowerCase();
+  const modelLower = String(model || '').toLowerCase();
+  const hasModelContext = errorMsg.includes('model')
+    || errorMsg.includes('模型')
+    || (modelLower && errorMsg.includes(modelLower));
+
+  if (hasModelContext && MODEL_UNAVAILABLE_HINTS.some(hint => errorMsg.includes(hint))) {
+    return 'unavailable';
+  }
+
+  if (statusCode === 400 || statusCode === 404 || statusCode === 405 || statusCode === 415 || statusCode === 422 || statusCode === 501) {
+    return 'retry';
+  }
+
+  return 'retry';
+}
+
+function sanitizeProbeErrorMessage(value) {
+  if (value === null || value === undefined) return '';
+  return String(value).replace(/\s+/g, ' ').trim().slice(0, 180);
+}
+
+function buildProbeFailureDetail(attempt, result) {
+  if (!attempt || !result) return null;
+  const statusCode = Number(result.statusCode) || 0;
+  const message = result.error?.message
+    ? sanitizeProbeErrorMessage(result.error.message)
+    : sanitizeProbeErrorMessage(extractProbeErrorMessage(result.responseBody));
+
+  return {
+    attempt: attempt.label || 'unknown',
+    statusCode,
+    message
+  };
+}
+
+function formatProbeFailureDetail(detail) {
+  if (!detail) return '';
+  const parts = [];
+  if (detail.attempt) parts.push(`attempt=${detail.attempt}`);
+  if (detail.statusCode) parts.push(`status=${detail.statusCode}`);
+  if (detail.message) parts.push(`msg=${detail.message}`);
+  if (parts.length === 0) return '';
+  return ` (${parts.join(', ')})`;
+}
+
+function executeProbeAttempt(attempt) {
+  return new Promise((resolve) => {
+    try {
+      const parsedUrl = new URL(attempt.url);
+      const isHttps = parsedUrl.protocol === 'https:';
+      const httpModule = isHttps ? https : http;
+      const requestBody = String(attempt.body || '');
+      const headers = {
+        ...(attempt.headers || {}),
+        'Content-Length': Buffer.byteLength(requestBody)
+      };
+
+      const options = {
+        hostname: parsedUrl.hostname,
+        port: parsedUrl.port || (isHttps ? 443 : 80),
+        path: parsedUrl.pathname + parsedUrl.search,
+        method: 'POST',
+        timeout: TEST_TIMEOUT_MS,
+        headers
+      };
+
+      const req = httpModule.request(options, (res) => {
+        collectResponseBody(res)
+          .then((data) => {
+            resolve({
+              statusCode: res.statusCode || 0,
+              responseBody: data
+            });
+          })
+          .catch((error) => {
+            resolve({
+              statusCode: 0,
+              responseBody: '',
+              error
+            });
+          });
+      });
+
+      req.on('error', (error) => resolve({
+        statusCode: 0,
+        responseBody: '',
+        error
+      }));
+      req.on('timeout', () => {
+        req.destroy();
+        resolve({
+          statusCode: 0,
+          responseBody: '',
+          error: new Error('Request timeout')
+        });
+      });
+
+      req.write(requestBody);
+      req.end();
+    } catch (error) {
+      resolve({
+        statusCode: 0,
+        responseBody: '',
+        error
+      });
+    }
+  });
+}
+
+function createDecodedStream(res) {
+  const encoding = String(res.headers['content-encoding'] || '').toLowerCase();
+  if (encoding.includes('gzip')) return res.pipe(zlib.createGunzip());
+  if (encoding.includes('deflate')) return res.pipe(zlib.createInflate());
+  if (encoding.includes('br') && typeof zlib.createBrotliDecompress === 'function') {
+    return res.pipe(zlib.createBrotliDecompress());
+  }
+  return res;
+}
+
+function collectResponseBody(res) {
+  return new Promise((resolve, reject) => {
+    const stream = createDecodedStream(res);
+    let data = '';
+
+    stream.on('data', chunk => {
+      data += chunk.toString('utf8');
+    });
+    stream.on('end', () => resolve(data));
+    stream.on('error', reject);
+    res.on('error', reject);
+  });
+}
+
 /**
  * Get cache file path
  */
 function getCacheFilePath() {
-  const dir = path.join(os.homedir(), '.claude', 'cc-tool');
+  const dir = path.join(os.homedir(), '.cc-tool');
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
@@ -256,18 +715,64 @@ function normalizeModelName(model) {
   return MODEL_ALIASES[normalized] || model;
 }
 
+function normalizeModelCandidates(models = []) {
+  if (!Array.isArray(models)) return [];
+  const seen = new Set();
+  const normalized = [];
+
+  models.forEach((model) => {
+    if (typeof model !== 'string') return;
+    const trimmed = model.trim();
+    if (!trimmed) return;
+    const canonical = normalizeModelName(trimmed) || trimmed;
+    const dedupeKey = canonical.toLowerCase();
+    if (seen.has(dedupeKey)) return;
+    seen.add(dedupeKey);
+    normalized.push(canonical);
+  });
+
+  return normalized;
+}
+
 /**
- * Check if cache entry is still valid
- * @param {Object} cacheEntry - Cache entry with lastChecked timestamp
- * @returns {boolean}
+ * Stable stringify with key ordering to build deterministic cache signatures
  */
-function isCacheValid(cacheEntry) {
-  if (!cacheEntry || !cacheEntry.lastChecked) {
-    return false;
+function stableStringify(value) {
+  if (value === null || value === undefined) return 'null';
+  if (Array.isArray(value)) {
+    return `[${value.map(item => stableStringify(item)).join(',')}]`;
   }
+  if (typeof value !== 'object') return JSON.stringify(value);
 
-  const age = Date.now() - new Date(cacheEntry.lastChecked).getTime();
-  return age < CACHE_DURATION_MS;
+  const keys = Object.keys(value).sort();
+  return `{${keys.map(key => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+}
+
+function buildChannelCacheSignature(channel, payload = {}) {
+  const base = {
+    id: channel?.id || '',
+    name: channel?.name || '',
+    baseUrl: channel?.baseUrl || '',
+    apiKey: channel?.apiKey || '',
+    gatewaySourceType: channel?.gatewaySourceType || '',
+    wireApi: channel?.wireApi || '',
+    model: channel?.model || '',
+    speedTestModel: channel?.speedTestModel || '',
+    presetId: channel?.presetId || '',
+    modelConfig: channel?.modelConfig || null,
+    modelRedirects: Array.isArray(channel?.modelRedirects) ? channel.modelRedirects : []
+  };
+  const raw = stableStringify({
+    channel: base,
+    payload
+  });
+
+  return crypto.createHash('sha1').update(raw).digest('hex');
+}
+
+function isSignatureCacheValid(cacheEntry, signatureKey, expectedSignature) {
+  if (!cacheEntry || !signatureKey || !expectedSignature) return false;
+  return cacheEntry[signatureKey] === expectedSignature;
 }
 
 /**
@@ -277,110 +782,45 @@ function isCacheValid(cacheEntry) {
  * @param {string} model - Model name to test
  * @returns {Promise<boolean>}
  */
-async function testModelAvailability(channel, channelType, model) {
-  return new Promise((resolve) => {
-    try {
-      const baseUrl = channel.baseUrl.trim().replace(/\/+$/, '');
-      let testUrl;
-      let requestBody;
-      // Start with common headers that look like legitimate SDK clients
-      let headers = {
-        ...buildRequestHeaders(channelType, channel),
-        'Content-Type': 'application/json'
-      };
-
-      // Construct API endpoint and request based on channel type
-      if (channelType === 'claude') {
-        testUrl = `${baseUrl}/v1/messages`;
-        headers['x-api-key'] = channel.apiKey;
-        headers['anthropic-version'] = '2023-06-01';
-        requestBody = JSON.stringify({
-          model: model,
-          max_tokens: 1,
-          messages: [{ role: 'user', content: 'test' }]
-        });
-      } else if (channelType === 'codex' || channelType === 'openai_compatible') {
-        // 处理 baseUrl 已包含 /v1 的情况
-        testUrl = baseUrl.endsWith('/v1')
-          ? `${baseUrl}/chat/completions`
-          : `${baseUrl}/v1/chat/completions`;
-        headers['Authorization'] = `Bearer ${channel.apiKey}`;
-        requestBody = JSON.stringify({
-          model: model,
-          max_tokens: 1,
-          messages: [{ role: 'user', content: 'test' }]
-        });
-      } else if (channelType === 'gemini') {
-        // Gemini uses API key in URL
-        testUrl = `${baseUrl}/v1beta/models/${model}:generateContent?key=${channel.apiKey}`;
-        requestBody = JSON.stringify({
-          contents: [{ parts: [{ text: 'test' }] }],
-          generationConfig: { maxOutputTokens: 1 }
-        });
-      } else {
-        return resolve(false);
-      }
-
-      const parsedUrl = new URL(testUrl);
-      const isHttps = parsedUrl.protocol === 'https:';
-      const httpModule = isHttps ? https : http;
+async function testModelAvailabilityDetailed(channel, channelType, model) {
+  try {
+    const attempts = buildProbeAttempts(channel, channelType, model);
+    if (!attempts.length) {
+      return { available: false, failureDetail: null };
+    }
 
-      const options = {
-        hostname: parsedUrl.hostname,
-        port: parsedUrl.port || (isHttps ? 443 : 80),
-        path: parsedUrl.pathname + parsedUrl.search,
-        method: 'POST',
-        timeout: TEST_TIMEOUT_MS,
-        headers: {
-          ...headers,
-          'Content-Length': Buffer.byteLength(requestBody)
+    let failureDetail = null;
+    for (const attempt of attempts) {
+      const result = await executeProbeAttempt(attempt);
+      if (result.error) {
+        if (!failureDetail) {
+          failureDetail = buildProbeFailureDetail(attempt, result);
         }
-      };
+        continue;
+      }
 
-      const req = httpModule.request(options, (res) => {
-        let data = '';
-        res.on('data', chunk => { data += chunk; });
-        res.on('end', () => {
-          // Success: 200-299 status codes
-          if (res.statusCode >= 200 && res.statusCode < 300) {
-            resolve(true);
-          } else if (res.statusCode === 400 || res.statusCode === 404) {
-            // 400/404 often means model not found or invalid
-            try {
-              const response = JSON.parse(data);
-              const errorMsg = (response.error?.message || '').toLowerCase();
-
-              // Check for model-specific errors
-              if (errorMsg.includes('model') &&
-                  (errorMsg.includes('not found') || errorMsg.includes('invalid') || errorMsg.includes('does not exist'))) {
-                resolve(false);
-              } else {
-                // Other 400 errors might be auth/validation issues, not model issues
-                resolve(true);
-              }
-            } catch {
-              resolve(false);
-            }
-          } else {
-            // Other errors (401, 403, 500, etc.) are inconclusive
-            resolve(false);
-          }
-        });
-      });
+      const verdict = classifyProbeResult(result.statusCode, result.responseBody, model);
+      if (verdict === 'available') {
+        return { available: true, failureDetail: null };
+      }
 
-      req.on('error', () => resolve(false));
-      req.on('timeout', () => {
-        req.destroy();
-        resolve(false);
-      });
+      if (!failureDetail) {
+        failureDetail = buildProbeFailureDetail(attempt, result);
+      }
+      if (verdict === 'unavailable') {
+        return { available: false, failureDetail };
+      }
+    }
 
-      req.write(requestBody);
-      req.end();
+    return { available: false, failureDetail };
+  } catch {
+    return { available: false, failureDetail: null };
+  }
+}
 
-    } catch (error) {
-      resolve(false);
-    }
-  });
+async function testModelAvailability(channel, channelType, model) {
+  const result = await testModelAvailabilityDetailed(channel, channelType, model);
+  return result.available;
 }
 
 /**
@@ -392,12 +832,23 @@ async function testModelAvailability(channel, channelType, model) {
  * @param {string} channelType - 'claude' | 'codex' | 'gemini'
  * @returns {Promise<Object>} { availableModels: string[], preferredTestModel: string|null, cached: boolean }
  */
-async function probeModelAvailability(channel, channelType) {
+async function probeModelAvailability(channel, channelType, options = {}) {
+  const forceRefresh = !!options.forceRefresh;
+  const toolType = options.toolType;
+  const stopOnFirstAvailable = !!options.stopOnFirstAvailable;
   const cache = loadModelCache();
   const cacheKey = channel.id;
+  const preferredModels = normalizeModelCandidates(options.preferredModels);
+  const probeSignature = buildChannelCacheSignature(channel, {
+    type: 'probe',
+    channelType: String(channelType || '').trim().toLowerCase(),
+    toolType: String(toolType || '').trim().toLowerCase(),
+    stopOnFirstAvailable,
+    preferredModels
+  });
 
-  // Return cached result if valid
-  if (cache[cacheKey] && isCacheValid(cache[cacheKey])) {
+  // Return cached result if channel and probe options are unchanged
+  if (!forceRefresh && isSignatureCacheValid(cache[cacheKey], 'probeSignature', probeSignature)) {
     return {
       availableModels: cache[cacheKey].availableModels || [],
       preferredTestModel: cache[cacheKey].preferredTestModel || null,
@@ -407,7 +858,8 @@ async function probeModelAvailability(channel, channelType) {
   }
 
   // Get model priority list for this channel type
-  const modelsToTest = MODEL_PRIORITY[channelType] || [];
+  const priorityModels = normalizeModelCandidates(getModelPriority(channelType, { toolType }));
+  const modelsToTest = normalizeModelCandidates([...preferredModels, ...priorityModels]);
   if (modelsToTest.length === 0) {
     console.warn(`[ModelDetector] No models defined for channel type: ${channelType}`);
     return {
@@ -431,13 +883,17 @@ async function probeModelAvailability(channel, channelType) {
     }
     isFirstModel = false;
 
-    const isAvailable = await testModelAvailability(channel, channelType, model);
+    const probeResult = await testModelAvailabilityDetailed(channel, channelType, model);
+    const isAvailable = probeResult.available;
 
     if (isAvailable) {
       availableModels.push(model);
       console.log(`[ModelDetector] ✓ ${model} available`);
+      if (stopOnFirstAvailable) {
+        break;
+      }
     } else {
-      console.log(`[ModelDetector] ✗ ${model} not available`);
+      console.log(`[ModelDetector] ✗ ${model} not available${formatProbeFailureDetail(probeResult.failureDetail)}`);
     }
   }
 
@@ -447,7 +903,10 @@ async function probeModelAvailability(channel, channelType) {
   const cacheEntry = {
     lastChecked: new Date().toISOString(),
     availableModels,
-    preferredTestModel
+    preferredTestModel,
+    probeSignature,
+    fetchedModels: cache[cacheKey]?.fetchedModels || [],
+    listSignature: cache[cacheKey]?.listSignature || null
   };
 
   cache[cacheKey] = cacheEntry;
@@ -491,7 +950,7 @@ function getCachedModelInfo(channelId) {
   const cache = loadModelCache();
   const entry = cache[channelId];
 
-  if (entry && isCacheValid(entry)) {
+  if (entry && (Array.isArray(entry.availableModels) || Array.isArray(entry.fetchedModels))) {
     return entry;
   }
 
@@ -504,10 +963,9 @@ function getCachedModelInfo(channelId) {
  * @param {string} channelType - 'claude' | 'codex' | 'gemini' | 'openai_compatible'
  * @returns {Promise<Object>} { models: string[], supported: boolean, cached: boolean, error: string|null, fallbackUsed: boolean }
  */
-async function fetchModelsFromProvider(channel, channelType) {
-  // PRESERVE original channel type for fallback model selection
-  const originalChannelType = channelType;
-
+async function fetchModelsFromProvider(channel, channelType, options = {}) {
+  const forceRefresh = !!options.forceRefresh;
+  const useV1ModelsEndpoint = shouldUseV1ModelsEndpoint(options);
   // Only auto-detect if channelType is NOT specified at all
   // DO NOT auto-detect when channelType is 'claude' - respect the caller's intent
   if (!channelType) {
@@ -515,6 +973,18 @@ async function fetchModelsFromProvider(channel, channelType) {
     console.log(`[ModelDetector] Auto-detected channel type: ${channelType} for ${channel.name}`);
   }
 
+  if (!useV1ModelsEndpoint) {
+    return {
+      models: [],
+      supported: true,
+      fallbackUsed: true,
+      cached: false,
+      disabledByConfig: true,
+      error: '已关闭 /v1/models 模型列表探测',
+      errorHint: '当前使用默认模型探测策略'
+    };
+  }
+
   // Check if provider supports model listing
   const capability = PROVIDER_CAPABILITIES[channelType];
   if (!capability || !capability.supportsModelList) {
@@ -529,9 +999,15 @@ async function fetchModelsFromProvider(channel, channelType) {
 
   const cache = loadModelCache();
   const cacheKey = channel.id;
+  const listSignature = buildChannelCacheSignature(channel, {
+    type: 'model-list',
+    channelType: String(channelType || '').trim().toLowerCase()
+  });
 
-  // Check cache first
-  if (cache[cacheKey] && isCacheValid(cache[cacheKey]) && cache[cacheKey].fetchedModels) {
+  // Check cache first, and only reuse when channel/list context is unchanged
+  if (!forceRefresh
+    && isSignatureCacheValid(cache[cacheKey], 'listSignature', listSignature)
+    && Array.isArray(cache[cacheKey].fetchedModels)) {
     return {
       models: cache[cacheKey].fetchedModels || [],
       supported: true,
@@ -559,8 +1035,10 @@ async function fetchModelsFromProvider(channel, channelType) {
       const headers = buildRequestHeaders(channelType, channel);
 
       // Add authentication header
-      if (capability.authHeader && channel.apiKey) {
-        headers['Authorization'] = `Bearer ${channel.apiKey}`;
+      if (capability.authHeader) {
+        if (channel.apiKey) {
+          headers['Authorization'] = `Bearer ${channel.apiKey}`;
+        }
       }
 
       const options = {
@@ -573,72 +1051,69 @@ async function fetchModelsFromProvider(channel, channelType) {
       };
 
       const req = httpModule.request(options, (res) => {
-        let data = '';
-        res.on('data', chunk => { data += chunk; });
-        res.on('end', () => {
-          // Handle different status codes
-          if (res.statusCode === 200) {
-            try {
-              const response = JSON.parse(data);
-
-              // Parse OpenAI-compatible format: { data: [{ id: "model-name", ... }] }
-              let models = [];
-              if (response.data && Array.isArray(response.data)) {
-                models = response.data
-                  .map(item => item.id || item.model)
-                  .filter(Boolean);
+        collectResponseBody(res)
+          .then((data) => {
+            // Handle different status codes
+            if (res.statusCode === 200) {
+              try {
+                const response = JSON.parse(data);
+
+                // Parse OpenAI-compatible format: { data: [{ id: "model-name", ... }] }
+                let models = [];
+                if (response.data && Array.isArray(response.data)) {
+                  models = response.data
+                    .map(item => item.id || item.model)
+                    .filter(Boolean);
+                }
+
+                // Update cache with fetched models
+                const cacheEntry = {
+                  lastChecked: new Date().toISOString(),
+                  fetchedModels: models,
+                  availableModels: cache[cacheKey]?.availableModels || [],
+                  preferredTestModel: cache[cacheKey]?.preferredTestModel || null,
+                  probeSignature: cache[cacheKey]?.probeSignature || null,
+                  listSignature
+                };
+
+                cache[cacheKey] = cacheEntry;
+                saveModelCache(cache);
+
+                console.log(`[ModelDetector] Fetched ${models.length} models from ${channel.name}`);
+
+                resolve({
+                  models,
+                  supported: true,
+                  cached: false,
+                  fallbackUsed: false,
+                  error: null,
+                  lastChecked: cacheEntry.lastChecked
+                });
+              } catch (parseError) {
+                console.error(`[ModelDetector] Failed to parse models response: ${parseError.message}`);
+                resolve({
+                  models: [],
+                  supported: true,
+                  cached: false,
+                  fallbackUsed: true,
+                  error: `Parse error: ${parseError.message}`
+                });
               }
-
-              // Update cache with fetched models
-              const cacheEntry = {
-                lastChecked: new Date().toISOString(),
-                fetchedModels: models,
-                availableModels: cache[cacheKey]?.availableModels || [],
-                preferredTestModel: cache[cacheKey]?.preferredTestModel || null
-              };
-
-              cache[cacheKey] = cacheEntry;
-              saveModelCache(cache);
-
-              console.log(`[ModelDetector] Fetched ${models.length} models from ${channel.name}`);
-
-              resolve({
-                models,
-                supported: true,
-                cached: false,
-                fallbackUsed: false,
-                error: null,
-                lastChecked: cacheEntry.lastChecked
-              });
-            } catch (parseError) {
-              console.error(`[ModelDetector] Failed to parse models response: ${parseError.message}`);
-              resolve({
-                models: [],
-                supported: true,
-                cached: false,
-                fallbackUsed: true,
-                error: `Parse error: ${parseError.message}`
-              });
-            }
-          } else if (res.statusCode === 401 || res.statusCode === 403) {
-            // Check if it's a Cloudflare protection issue
-            const bodyLower = data.toLowerCase();
-            const isCloudflare = bodyLower.includes('cloudflare') || bodyLower.includes('challenge') || bodyLower.includes('cf-ray');
+            } else if (res.statusCode === 401 || res.statusCode === 403) {
+              // Check if it's a Cloudflare protection issue
+              const bodyLower = data.toLowerCase();
+              const isCloudflare = bodyLower.includes('cloudflare') || bodyLower.includes('challenge') || bodyLower.includes('cf-ray');
 
             let errorMessage;
             let errorHint;
 
             if (isCloudflare) {
-              // Use originalChannelType for fallback to ensure correct models
-              // This prevents Claude channels from getting Codex models when using third-party proxies
-              const fallbackModels = MODEL_PRIORITY[originalChannelType || channelType] || MODEL_PRIORITY.claude;
-              const fallbackLabel = fallbackModels[0] || 'unknown';
-              errorMessage = 'Cloudflare 防护拦截，已使用默认模型列表';
-              errorHint = `该 API 端点受 Cloudflare 保护，已自动使用默认模型列表`;
-              console.warn(`[ModelDetector] Cloudflare protection detected for ${channel.name}, using default models for ${originalChannelType || channelType}`);
+              errorMessage = 'Cloudflare 防护拦截，无法自动获取模型列表';
+              errorHint = '该 API 端点受 Cloudflare 保护，请手动填写模型名称';
+              console.warn(`[ModelDetector] Cloudflare protection detected for ${channel.name}, no fallback models injected`);
               resolve({
-                models: fallbackModels,
-                supported: true,
+                models: [],
+                supported: false,
                 cached: false,
                 fallbackUsed: true,
                 error: errorMessage,
@@ -672,41 +1147,51 @@ async function fetchModelsFromProvider(channel, channelType) {
                 statusCode: res.statusCode
               });
             }
-          } else if (res.statusCode === 404) {
-            console.warn(`[ModelDetector] Model list endpoint not found for ${channel.name}`);
-            resolve({
-              models: [],
-              supported: false,
-              cached: false,
-              fallbackUsed: true,
-              error: '模型列表端点不存在',
-              errorHint: '该 API 可能不支持 /v1/models 接口，请手动输入模型名称',
-              statusCode: 404
-            });
-          } else if (res.statusCode === 429) {
-            console.warn(`[ModelDetector] Rate limited for ${channel.name}`);
-            resolve({
-              models: [],
-              supported: true,
-              cached: false,
-              fallbackUsed: true,
-              error: '请求频率限制',
-              errorHint: '请稍后再试或联系服务提供商提高限额',
-              statusCode: 429
-            });
-          } else {
-            console.error(`[ModelDetector] Unexpected status ${res.statusCode} for ${channel.name}`);
+            } else if (res.statusCode === 404) {
+              console.warn(`[ModelDetector] Model list endpoint not found for ${channel.name}`);
+              resolve({
+                models: [],
+                supported: false,
+                cached: false,
+                fallbackUsed: true,
+                error: '模型列表端点不存在',
+                errorHint: '该 API 可能不支持 /v1/models 接口，请手动输入模型名称',
+                statusCode: 404
+              });
+            } else if (res.statusCode === 429) {
+              console.warn(`[ModelDetector] Rate limited for ${channel.name}`);
+              resolve({
+                models: [],
+                supported: true,
+                cached: false,
+                fallbackUsed: true,
+                error: '请求频率限制',
+                errorHint: '请稍后再试或联系服务提供商提高限额',
+                statusCode: 429
+              });
+            } else {
+              console.error(`[ModelDetector] Unexpected status ${res.statusCode} for ${channel.name}`);
+              resolve({
+                models: [],
+                supported: true,
+                cached: false,
+                fallbackUsed: true,
+                error: `HTTP 错误 ${res.statusCode}`,
+                errorHint: '请检查 API 端点配置或联系服务提供商',
+                statusCode: res.statusCode
+              });
+            }
+          })
+          .catch((error) => {
+            console.error(`[ModelDetector] Failed to read models response: ${error.message}`);
             resolve({
               models: [],
               supported: true,
               cached: false,
               fallbackUsed: true,
-              error: `HTTP 错误 ${res.statusCode}`,
-              errorHint: '请检查 API 端点配置或联系服务提供商',
-              statusCode: res.statusCode
+              error: `Read error: ${error.message}`
             });
-          }
-        });
+          });
       });
 
       req.on('error', (error) => {
@@ -750,6 +1235,7 @@ async function fetchModelsFromProvider(channel, channelType) {
 module.exports = {
   probeModelAvailability,
   testModelAvailability,
+  getModelPriority,
   normalizeModelName,
   clearCache,
   getCachedModelInfo,