hedgequantx 2.6.93 → 2.6.94

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.6.93",
+  "version": "2.6.94",
   "description": "HedgeQuantX - Prop Futures Trading CLI",
   "main": "src/app.js",
   "bin": {

package/src/services/ai/client.js

@@ -592,9 +592,16 @@ const fetchOpenAIModels = async (endpoint, apiKey) => {
 
 /**
  * Fetch available models for OAuth-authenticated providers
+ * Uses multiple API endpoints to discover available models
+ * 
  * @param {string} providerId - Provider ID (anthropic, openai, gemini, etc.)
  * @param {string} accessToken - OAuth access token
- * @returns {Promise<Array|null>} Array of model IDs or null on error
+ * @returns {Promise<Array|null>} Array of model IDs from API, null if unavailable
+ * 
+ * Data sources:
+ * - OpenAI: https://api.openai.com/v1/models (GET)
+ * - Anthropic: https://api.anthropic.com/v1/models (GET)
+ * - Gemini: https://generativelanguage.googleapis.com/v1/models (GET)
  */
 const fetchModelsWithOAuth = async (providerId, accessToken) => {
   if (!accessToken) return null;
@@ -604,17 +611,48 @@ const fetchModelsWithOAuth = async (providerId, accessToken) => {
       case 'anthropic':
         return await fetchAnthropicModelsOAuth(accessToken);
       
-      case 'openai':
-        // OpenAI OAuth uses the same endpoint as API key
-        return await fetchOpenAIModels('https://api.openai.com/v1', accessToken);
+      case 'openai': {
+        // Try OpenAI /v1/models endpoint with OAuth token
+        const openaiModels = await fetchOpenAIModels('https://api.openai.com/v1', accessToken);
+        if (openaiModels && openaiModels.length > 0) {
+          return openaiModels;
+        }
+        
+        // Try alternative: ChatGPT backend API (for Plus/Pro plans)
+        try {
+          const chatgptUrl = 'https://chatgpt.com/backend-api/models';
+          const chatgptHeaders = {
+            'Authorization': `Bearer ${accessToken}`,
+            'Content-Type': 'application/json'
+          };
+          const chatgptResponse = await makeRequest(chatgptUrl, { 
+            method: 'GET', 
+            headers: chatgptHeaders, 
+            timeout: 10000 
+          });
+          if (chatgptResponse.models && Array.isArray(chatgptResponse.models)) {
+            return chatgptResponse.models
+              .map(m => m.slug || m.id || m.name)
+              .filter(Boolean);
+          }
+        } catch (e) {
+          // ChatGPT backend not available
+        }
+        
+        return null;
+      }
       
-      case 'gemini':
-        // Gemini OAuth - try to fetch from API
+      case 'gemini': {
+        // Gemini OAuth - fetch from Generative Language API
         const geminiUrl = 'https://generativelanguage.googleapis.com/v1/models';
         const geminiHeaders = {
           'Authorization': `Bearer ${accessToken}`
         };
-        const geminiResponse = await makeRequest(geminiUrl, { method: 'GET', headers: geminiHeaders, timeout: 10000 });
+        const geminiResponse = await makeRequest(geminiUrl, { 
+          method: 'GET', 
+          headers: geminiHeaders, 
+          timeout: 10000 
+        });
         if (geminiResponse.models && Array.isArray(geminiResponse.models)) {
           return geminiResponse.models
             .filter(m => m.supportedGenerationMethods?.includes('generateContent'))
@@ -622,6 +660,55 @@ const fetchModelsWithOAuth = async (providerId, accessToken) => {
             .filter(Boolean);
         }
         return null;
+      }
+      
+      case 'qwen': {
+        // Qwen - try to fetch models from Alibaba Cloud API
+        try {
+          const qwenUrl = 'https://dashscope.aliyuncs.com/api/v1/models';
+          const qwenHeaders = {
+            'Authorization': `Bearer ${accessToken}`,
+            'Content-Type': 'application/json'
+          };
+          const qwenResponse = await makeRequest(qwenUrl, { 
+            method: 'GET', 
+            headers: qwenHeaders, 
+            timeout: 10000 
+          });
+          if (qwenResponse.data && Array.isArray(qwenResponse.data)) {
+            return qwenResponse.data
+              .map(m => m.id || m.model_id)
+              .filter(Boolean);
+          }
+        } catch (e) {
+          // Qwen API may not support model listing
+        }
+        return null;
+      }
+      
+      case 'iflow': {
+        // iFlow - fetch models from iFlow API
+        try {
+          const iflowUrl = 'https://apis.iflow.cn/v1/models';
+          const iflowHeaders = {
+            'Authorization': `Bearer ${accessToken}`,
+            'Content-Type': 'application/json'
+          };
+          const iflowResponse = await makeRequest(iflowUrl, { 
+            method: 'GET', 
+            headers: iflowHeaders, 
+            timeout: 10000 
+          });
+          if (iflowResponse.data && Array.isArray(iflowResponse.data)) {
+            return iflowResponse.data
+              .map(m => m.id)
+              .filter(Boolean);
+          }
+        } catch (e) {
+          // iFlow API may not support model listing
+        }
+        return null;
+      }
       
       default:
         return null;