hedgequantx 2.6.92 → 2.6.94

package/package.json

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

package/src/menus/ai-agent.js

@@ -954,29 +954,14 @@ const setupBrowserOAuth = async (provider, config) => {
     // Fallback to default models if fetch fails
   }
   
-  // Fallback default models if API doesn't return list
-  // Updated January 2026 with latest models
-  const defaultModels = {
-    anthropic: ['claude-sonnet-4-20250514', 'claude-opus-4-20250514', 'claude-3-5-sonnet-20241022', 'claude-3-5-haiku-20241022'],
-    openai: [
-      'gpt-4.5-preview',      // NEW: GPT-4.5 (latest)
-      'gpt-4.5',              // NEW: GPT-4.5
-      'o3',                   // NEW: o3 (latest reasoning)
-      'o3-mini',              // o3-mini
-      'o1',                   // o1
-      'o1-mini',              // o1-mini
-      'gpt-4o',               // GPT-4o
-      'gpt-4o-mini',          // GPT-4o mini
-      'gpt-4-turbo',          // GPT-4 Turbo
-    ],
-    gemini: ['gemini-2.5-pro', 'gemini-2.5-flash', 'gemini-2.0-flash', 'gemini-1.5-pro'],
-    iflow: ['deepseek-v3', 'deepseek-chat', 'kimi', 'glm-4'],
-    qwen: ['qwen-max', 'qwen-plus', 'qwen-turbo', 'qwen2.5-72b-instruct']
-  };
-  
+  // NO hardcoded fallback - models MUST come from API
+  // Rule: ZERO fake/mock data - API only
   if (!models || models.length === 0) {
-    models = defaultModels[provider.id] || ['default'];
-    spinner.warn('USING DEFAULT MODEL LIST');
+    spinner.fail('NO MODELS AVAILABLE FROM API');
+    console.log(chalk.red('\n  Could not fetch models from provider API'));
+    console.log(chalk.gray('  Please check your OAuth credentials or try again'));
+    await prompts.waitForEnter();
+    return await selectProviderOption(provider);
   } else {
     spinner.succeed(`FOUND ${models.length} MODELS`);
   }

package/src/services/ai/client.js

@@ -541,6 +541,14 @@ const fetchGeminiModels = async (apiKey) => {
  * 
  * Data source: {endpoint}/models (GET)
  */
+/**
+ * Fetch available models from OpenAI-compatible API
+ * @param {string} endpoint - API endpoint base URL
+ * @param {string} apiKey - API key or OAuth token
+ * @returns {Promise<Array|null>} Array of model IDs from API, null if unavailable
+ * 
+ * Data source: {endpoint}/models (GET)
+ */
 const fetchOpenAIModels = async (endpoint, apiKey) => {
   if (!endpoint) return null;
   
@@ -554,44 +562,27 @@ const fetchOpenAIModels = async (endpoint, apiKey) => {
     headers['Authorization'] = `Bearer ${apiKey}`;
   }
   
-  // Priority order for OpenAI models (newest/best first)
-  const modelPriority = [
-    'gpt-4.5-preview', 'gpt-4.5',
-    'o3', 'o3-mini', 'o3-mini-high',
-    'o1', 'o1-pro', 'o1-mini',
-    'gpt-4o', 'gpt-4o-mini', 'gpt-4o-audio-preview',
-    'gpt-4-turbo', 'gpt-4-turbo-preview',
-    'gpt-4', 'gpt-3.5-turbo'
-  ];
-  
   try {
     const response = await makeRequest(url, { method: 'GET', headers, timeout: 10000 });
     if (response.data && Array.isArray(response.data)) {
-      const allModels = response.data.map(m => m.id).filter(Boolean);
+      // Return models from API - filter to chat models only
+      const chatModels = response.data
+        .map(m => m.id)
+        .filter(id => id && (
+          id.includes('gpt') || 
+          id.includes('o1') || 
+          id.includes('o3') ||
+          id.includes('claude') ||
+          id.includes('gemini')
+        ))
+        .filter(id => 
+          !id.includes('embedding') &&
+          !id.includes('whisper') &&
+          !id.includes('tts') &&
+          !id.includes('dall-e')
+        );
       
-      // Filter to only chat/completion models, exclude embeddings/audio-only etc
-      const chatModels = allModels.filter(m => 
-        (m.includes('gpt') || m.includes('o1') || m.includes('o3')) &&
-        !m.includes('embedding') &&
-        !m.includes('whisper') &&
-        !m.includes('tts') &&
-        !m.includes('dall-e') &&
-        !m.includes('davinci') &&
-        !m.includes('babbage') &&
-        !m.includes('instruct')
-      );
-      
-      // Sort by priority
-      chatModels.sort((a, b) => {
-        const aIdx = modelPriority.findIndex(p => a.includes(p));
-        const bIdx = modelPriority.findIndex(p => b.includes(p));
-        if (aIdx === -1 && bIdx === -1) return 0;
-        if (aIdx === -1) return 1;
-        if (bIdx === -1) return -1;
-        return aIdx - bIdx;
-      });
-      
-      return chatModels.length > 0 ? chatModels : allModels;
+      return chatModels.length > 0 ? chatModels : null;
     }
     return null;
   } catch (error) {
@@ -601,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;
@@ -613,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'))
@@ -631,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;