hedgequantx 2.6.99 → 2.6.101

package/package.json

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

package/src/menus/ai-agent.js

@@ -892,25 +892,39 @@ const setupRemoteOAuth = async (provider, config) => {
   };
   
   // Try to fetch models with the new token
-  spinner.text = 'Fetching available models...';
+  spinner.text = 'Fetching available models from API...';
   spinner.start();
   
   let models = [];
+  let fetchError = null;
   try {
     const { fetchModelsWithOAuth } = require('../services/ai/client');
     models = await fetchModelsWithOAuth(provider.id, result.access);
   } catch (e) {
-    // Ignore - will use defaults
+    fetchError = e.message;
   }
   
-  // Use defaults if API doesn't return models
+  // RULE: Models MUST come from API - no hardcoded fallback
   if (!models || models.length === 0) {
-    models = getDefaultModelsForProvider(provider.id);
+    spinner.fail('Could not fetch models from API');
+    console.log();
+    console.log(chalk.red('  ERROR: Unable to retrieve models from provider API'));
+    console.log(chalk.white('  Possible causes:'));
+    console.log(chalk.gray('  - OAuth token may not have permission to list models'));
+    console.log(chalk.gray('  - Network issue or API temporarily unavailable'));
+    console.log(chalk.gray('  - Provider API may have changed'));
+    if (fetchError) {
+      console.log(chalk.gray(`  - Error: ${fetchError}`));
+    }
+    console.log();
+    console.log(chalk.yellow('  Please try again or use API Key authentication instead.'));
+    await prompts.waitForEnter();
+    return await selectProviderOption(provider);
   }
   
   spinner.succeed(`Found ${models.length} models`);
   
-  // Let user select model
+  // Let user select model from list
   const selectedModel = await selectModelFromList(models, config.name);
   if (!selectedModel) {
     return await selectProviderOption(provider);
@@ -931,35 +945,7 @@ const setupRemoteOAuth = async (provider, config) => {
   return await aiAgentMenu();
 };
 
-/**
- * Get default models for a provider (used when we can't query the API)
- */
-const getDefaultModelsForProvider = (providerId) => {
-  // These are fetched from provider APIs - not hardcoded fallbacks
-  // They represent the known model IDs that the provider supports
-  const models = {
-    anthropic: [
-      'claude-sonnet-4-20250514',
-      'claude-opus-4-20250514', 
-      'claude-3-5-sonnet-20241022',
-      'claude-3-5-haiku-20241022',
-      'claude-3-opus-20240229'
-    ],
-    openai: [
-      'gpt-4o',
-      'gpt-4o-mini',
-      'gpt-4-turbo',
-      'o1-preview',
-      'o1-mini'
-    ],
-    gemini: [
-      'gemini-2.0-flash-exp',
-      'gemini-1.5-pro',
-      'gemini-1.5-flash'
-    ]
-  };
-  return models[providerId] || [];
-};
+// NOTE: promptForModelName was removed - models MUST come from API (RULES.md)
 
 /**
  * Setup OAuth via Manual Code Entry (unified flow for local and VPS)
@@ -1256,7 +1242,7 @@ const setupDeviceFlowOAuth = async (provider, config) => {
     return await selectProviderOption(provider);
   }
   
-  pollSpinner.text = 'FETCHING AVAILABLE MODELS...';
+  pollSpinner.text = 'FETCHING AVAILABLE MODELS FROM API...';
   
   // Store OAuth credentials
   const credentials = {
@@ -1268,13 +1254,36 @@ const setupDeviceFlowOAuth = async (provider, config) => {
     }
   };
   
-  // Default models for Qwen
-  const defaultModels = ['qwen3-coder-plus', 'qwen3-235b', 'qwen-max', 'qwen-plus', 'qwen-turbo'];
+  // Fetch models from API - NO hardcoded fallback (RULES.md)
+  let models = [];
+  let fetchError = null;
+  try {
+    const { fetchModelsWithOAuth } = require('../services/ai/client');
+    models = await fetchModelsWithOAuth(provider.id, pollResult.access);
+  } catch (e) {
+    fetchError = e.message;
+  }
+  
+  if (!models || models.length === 0) {
+    pollSpinner.fail('Could not fetch models from API');
+    console.log();
+    console.log(chalk.red('  ERROR: Unable to retrieve models from provider API'));
+    console.log(chalk.white('  Possible causes:'));
+    console.log(chalk.gray('  - OAuth token may not have permission to list models'));
+    console.log(chalk.gray('  - Network issue or API temporarily unavailable'));
+    if (fetchError) {
+      console.log(chalk.gray(`  - Error: ${fetchError}`));
+    }
+    console.log();
+    console.log(chalk.yellow('  Please try again or use API Key authentication instead.'));
+    await prompts.waitForEnter();
+    return await selectProviderOption(provider);
+  }
   
-  pollSpinner.succeed('AUTHENTICATION SUCCESSFUL');
+  pollSpinner.succeed(`Found ${models.length} models`);
   
-  // Let user select model
-  const selectedModel = await selectModelFromList(defaultModels, config.name);
+  // Let user select model from API list
+  const selectedModel = await selectModelFromList(models, config.name);
   if (!selectedModel) {
     return await selectProviderOption(provider);
   }

package/src/services/ai/client.js

@@ -525,15 +525,17 @@ const fetchAnthropicModels = async (apiKey) => {
 
 /**
  * Fetch available models from Anthropic API (OAuth auth)
+ * 
  * @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 source: https://api.anthropic.com/v1/models (GET with Bearer token)
+ * NO HARDCODED FALLBACK - models must come from API only
  */
 const fetchAnthropicModelsOAuth = async (accessToken) => {
   if (!accessToken) return null;
   
-  const url = 'https://api.anthropic.com/v1/models';
+  const modelsUrl = 'https://api.anthropic.com/v1/models';
   
   const headers = {
     'Authorization': `Bearer ${accessToken}`,
@@ -542,14 +544,16 @@ const fetchAnthropicModelsOAuth = async (accessToken) => {
   };
   
   try {
-    const response = await makeRequest(url, { method: 'GET', headers, timeout: 10000 });
+    const response = await makeRequest(modelsUrl, { method: 'GET', headers, timeout: 15000 });
     if (response.data && Array.isArray(response.data)) {
       const models = response.data.map(m => m.id).filter(Boolean);
       if (models.length > 0) return models;
     }
     return null;
   } catch (error) {
-    // OAuth token may not support /models endpoint
+    if (process.env.HQX_DEBUG) {
+      console.error('[DEBUG] fetchAnthropicModelsOAuth error:', error.message);
+    }
     return null;
   }
 };
@@ -661,6 +665,7 @@ const fetchModelsWithOAuth = async (providerId, accessToken) => {
       
       case 'openai': {
         // Try OpenAI /v1/models endpoint with OAuth token
+        // NO HARDCODED FALLBACK - models must come from API only
         const openaiModels = await fetchOpenAIModels('https://api.openai.com/v1', accessToken);
         if (openaiModels && openaiModels.length > 0) {
           return openaiModels;
@@ -684,7 +689,9 @@ const fetchModelsWithOAuth = async (providerId, accessToken) => {
               .filter(Boolean);
           }
         } catch (e) {
-          // ChatGPT backend not available
+          if (process.env.HQX_DEBUG) {
+            console.error('[DEBUG] ChatGPT backend error:', e.message);
+          }
         }
         
         return null;
@@ -692,21 +699,30 @@ const fetchModelsWithOAuth = async (providerId, accessToken) => {
       
       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 
-        });
-        if (geminiResponse.models && Array.isArray(geminiResponse.models)) {
-          return geminiResponse.models
-            .filter(m => m.supportedGenerationMethods?.includes('generateContent'))
-            .map(m => m.name.replace('models/', ''))
-            .filter(Boolean);
+        // NO HARDCODED FALLBACK - models must come from API only
+        try {
+          const geminiUrl = 'https://generativelanguage.googleapis.com/v1/models';
+          const geminiHeaders = {
+            'Authorization': `Bearer ${accessToken}`
+          };
+          const geminiResponse = await makeRequest(geminiUrl, { 
+            method: 'GET', 
+            headers: geminiHeaders, 
+            timeout: 15000 
+          });
+          if (geminiResponse.models && Array.isArray(geminiResponse.models)) {
+            const models = geminiResponse.models
+              .filter(m => m.supportedGenerationMethods?.includes('generateContent'))
+              .map(m => m.name.replace('models/', ''))
+              .filter(Boolean);
+            if (models.length > 0) return models;
+          }
+        } catch (e) {
+          if (process.env.HQX_DEBUG) {
+            console.error('[DEBUG] Gemini models API error:', e.message);
+          }
         }
+        
         return null;
       }