@adversity/coding-tool-x 3.0.0 → 3.0.2

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

@@ -23,6 +23,78 @@ const MODEL_PRIORITY = {
   gemini: ['gemini-2.5-flash', 'gemini-2.5-pro']
 };
 
+const PROVIDER_CAPABILITIES = {
+  claude: {
+    supportsModelList: false,
+    modelListEndpoint: null,
+    fallbackStrategy: 'probe'
+  },
+  codex: {
+    supportsModelList: true,
+    modelListEndpoint: '/v1/models',
+    authHeader: 'Authorization: Bearer'
+  },
+  gemini: {
+    supportsModelList: false,
+    modelListEndpoint: null,
+    fallbackStrategy: 'probe'
+  },
+  openai_compatible: {
+    supportsModelList: true,
+    modelListEndpoint: '/v1/models',
+    authHeader: 'Authorization: Bearer'
+  }
+};
+
+/**
+ * Auto-detect channel type based on baseUrl
+ * @param {Object} channel - Channel configuration
+ * @returns {string} - 'claude' | 'codex' | 'gemini' | 'openai_compatible'
+ */
+function detectChannelType(channel) {
+  try {
+    // Parse the URL to extract hostname
+    const parsedUrl = new URL(channel.baseUrl);
+    const hostname = parsedUrl.hostname.toLowerCase();
+
+    // Check if it's official Anthropic API (hostname only, not path)
+    if (hostname.includes('anthropic.com') || hostname.includes('claude.ai')) {
+      return 'claude';
+    }
+
+    // Check if it's Gemini (hostname only)
+    if (hostname.includes('generativelanguage.googleapis.com') || hostname.includes('gemini')) {
+      return 'gemini';
+    }
+
+    // Check if it's OpenAI official (hostname only)
+    if (hostname.includes('api.openai.com')) {
+      return 'codex';
+    }
+
+    // All other third-party proxies default to OpenAI compatible
+    // Including: 88code, anyrouter, internal proxies, etc.
+    // This correctly handles URLs like https://code.newcli.com/claude/aws
+    return 'openai_compatible';
+  } catch (error) {
+    // If URL parsing fails, fall back to string matching on full URL
+    console.warn(`[ModelDetector] Failed to parse URL ${channel.baseUrl}: ${error.message}`);
+    const baseUrl = channel.baseUrl.toLowerCase();
+
+    if (baseUrl.includes('anthropic.com') || baseUrl.includes('claude.ai')) {
+      return 'claude';
+    }
+    if (baseUrl.includes('generativelanguage.googleapis.com')) {
+      return 'gemini';
+    }
+    if (baseUrl.includes('api.openai.com')) {
+      return 'codex';
+    }
+
+    return 'openai_compatible';
+  }
+}
+
 // Model name normalization mapping
 const MODEL_ALIASES = {
   // Claude variants
@@ -340,11 +412,208 @@ function getCachedModelInfo(channelId) {
   return null;
 }
 
+/**
+ * Fetch available models from provider's /v1/models endpoint
+ * @param {Object} channel - Channel configuration
+ * @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) {
+  // If no type specified or type is 'claude', auto-detect
+  if (!channelType || channelType === 'claude') {
+    channelType = detectChannelType(channel);
+    console.log(`[ModelDetector] Auto-detected channel type: ${channelType} for ${channel.name}`);
+  }
+
+  // Check if provider supports model listing
+  const capability = PROVIDER_CAPABILITIES[channelType];
+  if (!capability || !capability.supportsModelList) {
+    return {
+      models: [],
+      supported: false,
+      fallbackUsed: true,
+      cached: false,
+      error: null
+    };
+  }
+
+  const cache = loadModelCache();
+  const cacheKey = channel.id;
+
+  // Check cache first
+  if (cache[cacheKey] && isCacheValid(cache[cacheKey]) && cache[cacheKey].fetchedModels) {
+    return {
+      models: cache[cacheKey].fetchedModels || [],
+      supported: true,
+      cached: true,
+      fallbackUsed: false,
+      error: null,
+      lastChecked: cache[cacheKey].lastChecked
+    };
+  }
+
+  return new Promise((resolve) => {
+    try {
+      const baseUrl = channel.baseUrl.trim().replace(/\/+$/, '');
+      const endpoint = capability.modelListEndpoint;
+      const requestUrl = `${baseUrl}${endpoint}`;
+
+      const parsedUrl = new URL(requestUrl);
+      const isHttps = parsedUrl.protocol === 'https:';
+      const httpModule = isHttps ? https : http;
+
+      const headers = {
+        'User-Agent': 'Coding-Tool-ModelDetector/1.0',
+        'Accept': 'application/json'
+      };
+
+      // Add authentication header
+      if (capability.authHeader && channel.apiKey) {
+        headers['Authorization'] = `Bearer ${channel.apiKey}`;
+      }
+
+      const options = {
+        hostname: parsedUrl.hostname,
+        port: parsedUrl.port || (isHttps ? 443 : 80),
+        path: parsedUrl.pathname + parsedUrl.search,
+        method: 'GET',
+        timeout: TEST_TIMEOUT_MS,
+        headers
+      };
+
+      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);
+              }
+
+              // 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) {
+            console.error(`[ModelDetector] Authentication failed for ${channel.name}: ${res.statusCode}`);
+            resolve({
+              models: [],
+              supported: true,
+              cached: false,
+              fallbackUsed: true,
+              error: `Authentication failed: ${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: 'Endpoint not found (404)'
+            });
+          } else if (res.statusCode === 429) {
+            console.warn(`[ModelDetector] Rate limited for ${channel.name}`);
+            resolve({
+              models: [],
+              supported: true,
+              cached: false,
+              fallbackUsed: true,
+              error: 'Rate limited (429)'
+            });
+          } else {
+            console.error(`[ModelDetector] Unexpected status ${res.statusCode} for ${channel.name}`);
+            resolve({
+              models: [],
+              supported: true,
+              cached: false,
+              fallbackUsed: true,
+              error: `HTTP ${res.statusCode}`
+            });
+          }
+        });
+      });
+
+      req.on('error', (error) => {
+        console.error(`[ModelDetector] Network error fetching models from ${channel.name}: ${error.message}`);
+        resolve({
+          models: [],
+          supported: true,
+          cached: false,
+          fallbackUsed: true,
+          error: `Network error: ${error.message}`
+        });
+      });
+
+      req.on('timeout', () => {
+        req.destroy();
+        console.error(`[ModelDetector] Timeout fetching models from ${channel.name}`);
+        resolve({
+          models: [],
+          supported: true,
+          cached: false,
+          fallbackUsed: true,
+          error: 'Request timeout'
+        });
+      });
+
+      req.end();
+
+    } catch (error) {
+      console.error(`[ModelDetector] Error in fetchModelsFromProvider: ${error.message}`);
+      resolve({
+        models: [],
+        supported: true,
+        cached: false,
+        fallbackUsed: true,
+        error: error.message
+      });
+    }
+  });
+}
+
 module.exports = {
   probeModelAvailability,
   testModelAvailability,
   normalizeModelName,
   clearCache,
   getCachedModelInfo,
+  fetchModelsFromProvider,
+  detectChannelType,
   MODEL_PRIORITY
 };

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

@@ -199,10 +199,22 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
   // Probe model availability if channel is provided
   let modelProbe = null;
   if (channel) {
-    try {
-      modelProbe = await probeModelAvailability(channel, channelType);
-    } catch (error) {
-      console.error('[SpeedTest] Model detection failed:', error.message);
+    // Check if speedTestModel is explicitly configured
+    if (channel.speedTestModel) {
+      // Use the explicitly configured model for speed testing
+      modelProbe = {
+        preferredTestModel: channel.speedTestModel,
+        availableModels: [channel.speedTestModel],
+        cached: false
+      };
+      console.log(`[SpeedTest] Using configured speedTestModel: ${channel.speedTestModel}`);
+    } else {
+      // Fall back to auto-detection
+      try {
+        modelProbe = await probeModelAvailability(channel, channelType);
+      } catch (error) {
+        console.error('[SpeedTest] Model detection failed:', error.message);
+      }
     }
   }
 
@@ -243,7 +255,7 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
       const sessionId = Math.random().toString(36).substring(2, 15);
       requestBody = JSON.stringify({
         model: testModel,
-        max_tokens: 10,
+        max_tokens: 1,
         stream: true,
         messages: [{ role: 'user', content: [{ type: 'text', text: 'Hi' }] }],
         system: [{ type: 'text', text: "You are Claude Code, Anthropic's official CLI for Claude." }],
@@ -288,7 +300,7 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
           model: testModel,
           instructions: 'You are Codex.',
           input: [{ type: 'message', role: 'user', content: [{ type: 'input_text', text: 'ping' }] }],
-          max_output_tokens: 10,
+          max_output_tokens: 1,
           stream: false,
           store: false
         });
@@ -309,7 +321,7 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
       testModel = modelProbe?.preferredTestModel || model || 'gemini-2.5-pro';
       requestBody = JSON.stringify({
         model: testModel,
-        max_tokens: 10,
+        max_tokens: 1,
         messages: [{ role: 'user', content: 'Hi' }]
       });
       headers = {
@@ -325,7 +337,7 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
       }
       requestBody = JSON.stringify({
         model: 'gpt-4o-mini',
-        max_tokens: 10,
+        max_tokens: 1,
         messages: [{ role: 'user', content: 'Hi' }]
       });
       headers = {
@@ -359,6 +371,41 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
         }
       };
 
+      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();
@@ -377,17 +424,19 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
               statusCode: res.statusCode
             }));
           } else if (chunkStr.includes('"detail"') || chunkStr.includes('"error"')) {
-            // 流式响应中的错误
-            resolved = true;
-            const latency = Date.now() - startTime;
-            req.destroy();
-            const errMsg = parseErrorMessage(chunkStr) || '流式响应错误';
-            resolve(createResult({
-              success: false,
-              latency,
-              error: errMsg,
-              statusCode: res.statusCode
-            }));
+            // 流式响应中的错误 - 使用新的错误检测函数
+            const errorCheck = containsUnexpectedError(chunkStr);
+            if (errorCheck.hasError) {
+              resolved = true;
+              const latency = Date.now() - startTime;
+              req.destroy();
+              resolve(createResult({
+                success: false,
+                latency,
+                error: errorCheck.message,
+                statusCode: res.statusCode
+              }));
+            }
           }
         }
       });
@@ -399,14 +448,13 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
 
         // 严格判断：只有 2xx 且没有错误信息才算成功
         if (res.statusCode >= 200 && res.statusCode < 300) {
-          // 检查响应体是否包含错误信息
-          const errMsg = parseErrorMessage(data);
-          if (errMsg && (errMsg.includes('error') || errMsg.includes('Error') ||
-                         errMsg.includes('失败') || errMsg.includes('错误'))) {
+          // 使用新的错误检测函数
+          const errorCheck = containsUnexpectedError(data);
+          if (errorCheck.hasError) {
             resolve(createResult({
               success: false,
               latency,
-              error: errMsg,
+              error: errorCheck.message,
               statusCode: res.statusCode
             }));
           } else {