hedgequantx 2.6.74 → 2.6.76

package/package.json

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

package/src/menus/ai-agent.js

@@ -858,13 +858,22 @@ const setupBrowserOAuth = async (provider, config) => {
   } else {
     console.log(makeLine(chalk.yellow('COULD NOT OPEN BROWSER (VPS/SSH?)')));
     console.log(makeLine(''));
-    console.log(makeLine(chalk.white('AFTER LOGGING IN, YOU WILL SEE A CODE')));
-    console.log(makeLine(chalk.white('COPY THE ENTIRE CODE AND PASTE IT BELOW')));
-    console.log(makeLine(''));
-    if (config.codeFormat) {
-      console.log(makeLine(chalk.white(`THE CODE LOOKS LIKE: ${config.codeFormat}`)));
+    
+    // Different instructions for different providers
+    if (provider.id === 'anthropic') {
+      console.log(makeLine(chalk.white('AFTER LOGGING IN, YOU WILL SEE A CODE')));
+      console.log(makeLine(chalk.white('COPY THE ENTIRE CODE AND PASTE IT BELOW')));
+      console.log(makeLine(''));
+      console.log(makeLine(chalk.white('THE CODE LOOKS LIKE: abc123...#xyz789...')));
+    } else {
+      // Gemini, OpenAI, iFlow redirect to localhost - need full URL
+      console.log(makeLine(chalk.white('AFTER LOGGING IN, YOU WILL SEE A BLANK PAGE')));
+      console.log(makeLine(chalk.white('THE URL WILL START WITH: localhost:...')));
       console.log(makeLine(''));
+      console.log(makeLine(chalk.green('COPY THE ENTIRE URL FROM THE ADDRESS BAR')));
+      console.log(makeLine(chalk.white('AND PASTE IT BELOW')));
     }
+    console.log(makeLine(''));
     console.log(makeLine(chalk.white('TYPE < TO CANCEL')));
     drawBoxFooter(boxWidth);
     // Display URL outside the box for easy copy-paste (no line breaks)
@@ -875,24 +884,41 @@ const setupBrowserOAuth = async (provider, config) => {
     console.log();
   }
   
-  const code = await prompts.textInput(chalk.cyan('PASTE AUTHORIZATION CODE:'));
+  const promptText = provider.id === 'anthropic' 
+    ? 'PASTE AUTHORIZATION CODE:' 
+    : 'PASTE FULL CALLBACK URL:';
+  
+  const input = await prompts.textInput(chalk.cyan(promptText));
   
-  if (!code || code === '<') {
+  if (!input || input === '<') {
     return await selectProviderOption(provider);
   }
   
+  // Extract code from URL if user pasted full callback URL
+  let code = input.trim();
+  if (code.includes('code=')) {
+    try {
+      const urlObj = new URL(code.replace('localhost', 'http://localhost'));
+      code = urlObj.searchParams.get('code') || code;
+    } catch (e) {
+      // Try regex extraction as fallback
+      const match = code.match(/[?&]code=([^&]+)/);
+      if (match) code = match[1];
+    }
+  }
+  
   // Exchange code for tokens
   const spinner = ora({ text: 'EXCHANGING CODE FOR TOKENS...', color: 'cyan' }).start();
   
   let result;
   if (provider.id === 'anthropic') {
-    result = await config.oauthModule.exchange(code.trim(), verifier);
+    result = await config.oauthModule.exchange(code, verifier);
   } else if (provider.id === 'gemini') {
-    result = await config.oauthModule.exchange(code.trim());
+    result = await config.oauthModule.exchange(code);
   } else if (provider.id === 'iflow') {
-    result = await config.oauthModule.exchange(code.trim(), redirectUri);
+    result = await config.oauthModule.exchange(code, redirectUri);
   } else {
-    result = await config.oauthModule.exchange(code.trim(), verifier);
+    result = await config.oauthModule.exchange(code, verifier);
   }
   
   if (result.type === 'failed') {
@@ -901,7 +927,7 @@ const setupBrowserOAuth = async (provider, config) => {
     return await selectProviderOption(provider);
   }
   
-  spinner.succeed('AUTHENTICATION SUCCESSFUL');
+  spinner.text = 'FETCHING AVAILABLE MODELS...';
   
   // Store OAuth credentials
   const credentials = {
@@ -919,15 +945,35 @@ const setupBrowserOAuth = async (provider, config) => {
     credentials.apiKey = result.apiKey;
   }
   
-  // Use default model for OAuth providers (they typically have limited model access)
+  // Fetch available models for the provider
+  let models = [];
+  try {
+    const { fetchModelsWithOAuth } = require('../services/ai/client');
+    models = await fetchModelsWithOAuth(provider.id, result.access);
+  } catch (e) {
+    // Fallback to default models if fetch fails
+  }
+  
+  // Fallback default models if API doesn't return list
   const defaultModels = {
-    anthropic: 'claude-sonnet-4-20250514',
-    openai: 'gpt-4o',
-    gemini: 'gemini-2.5-pro',
-    iflow: 'deepseek-v3'
+    anthropic: ['claude-sonnet-4-20250514', 'claude-opus-4-20250514', 'claude-3-5-sonnet-20241022', 'claude-3-5-haiku-20241022'],
+    openai: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1', 'o1-mini', 'o3-mini'],
+    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']
   };
   
-  const selectedModel = defaultModels[provider.id] || 'default';
+  if (!models || models.length === 0) {
+    models = defaultModels[provider.id] || ['default'];
+    spinner.warn('USING DEFAULT MODEL LIST');
+  } else {
+    spinner.succeed(`FOUND ${models.length} MODELS`);
+  }
+  
+  // Let user select model
+  const selectedModel = await selectModelFromList(models, config.name);
+  if (!selectedModel) {
+    return await selectProviderOption(provider);
+  }
   
   // Add agent with OAuth credentials
   try {
@@ -1040,7 +1086,7 @@ const setupDeviceFlowOAuth = async (provider, config) => {
     return await selectProviderOption(provider);
   }
   
-  pollSpinner.succeed('AUTHENTICATION SUCCESSFUL');
+  pollSpinner.text = 'FETCHING AVAILABLE MODELS...';
   
   // Store OAuth credentials
   const credentials = {
@@ -1052,7 +1098,16 @@ const setupDeviceFlowOAuth = async (provider, config) => {
     }
   };
   
-  const selectedModel = 'qwen3-coder-plus';
+  // Default models for Qwen
+  const defaultModels = ['qwen3-coder-plus', 'qwen3-235b', 'qwen-max', 'qwen-plus', 'qwen-turbo'];
+  
+  pollSpinner.succeed('AUTHENTICATION SUCCESSFUL');
+  
+  // Let user select model
+  const selectedModel = await selectModelFromList(defaultModels, config.name);
+  if (!selectedModel) {
+    return await selectProviderOption(provider);
+  }
   
   // Add agent with OAuth credentials
   try {

package/src/services/ai/client.js

@@ -565,6 +565,47 @@ const fetchOpenAIModels = async (endpoint, apiKey) => {
   }
 };
 
+/**
+ * Fetch available models for OAuth-authenticated providers
+ * @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
+ */
+const fetchModelsWithOAuth = async (providerId, accessToken) => {
+  if (!accessToken) return null;
+  
+  try {
+    switch (providerId) {
+      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 'gemini':
+        // Gemini OAuth - try to fetch from 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);
+        }
+        return null;
+      
+      default:
+        return null;
+    }
+  } catch (error) {
+    return null;
+  }
+};
+
 module.exports = {
   callAI,
   analyzeTrading,
@@ -577,5 +618,6 @@ module.exports = {
   fetchAnthropicModelsOAuth,
   fetchGeminiModels,
   fetchOpenAIModels,
+  fetchModelsWithOAuth,
   getValidOAuthToken
 };