hedgequantx 2.6.123 → 2.6.125

package/package.json

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

package/src/menus/ai-agent.js

@@ -1106,48 +1106,31 @@ const setupProxyOAuth = async (provider, config) => {
   
   // Wrap entire post-auth flow in try-catch to catch any uncaught errors
   try {
-    // Step 5: Fetch models from CLIProxyAPI
+    // Step 5: Fetch models from CLIProxyAPI (filtered by provider)
     const modelSpinner = ora({ text: 'Fetching available models from API...', color: 'cyan' }).start();
     
     let models = [];
     try {
-      models = await proxyManager.getModels();
-      modelSpinner.succeed(`Found ${models.length} models`);
+      // Get models filtered by provider using owned_by field from API
+      models = await proxyManager.getModels(provider.id);
+      modelSpinner.succeed(`Found ${models.length} models for ${provider.name}`);
     } catch (error) {
       modelSpinner.fail(`Failed to fetch models: ${error.message}`);
       await prompts.waitForEnter();
       return await selectProviderOption(provider);
     }
     
-    // Filter models for this provider
-    const providerPrefixes = {
-      anthropic: ['claude'],
-      openai: ['gpt', 'o1', 'o3', 'o4'],
-      gemini: ['gemini'],
-      qwen: ['qwen'],
-      iflow: ['deepseek', 'kimi', 'glm']
-    };
-    
-    const prefixes = providerPrefixes[provider.id] || [];
-    const filteredModels = models.filter(m => {
-      const modelLower = m.toLowerCase();
-      return prefixes.some(p => modelLower.includes(p));
-    });
-    
-    // Use filtered models if available, otherwise use all models
-    const availableModels = filteredModels.length > 0 ? filteredModels : models;
-    
-    if (!availableModels || availableModels.length === 0) {
+    if (!models || models.length === 0) {
       console.log();
       console.log(chalk.red('  ERROR: No models found for this provider'));
-      console.log(chalk.gray('  Make sure your subscription is active.'));
+      console.log(chalk.gray('  Make sure your subscription is active and authorization completed.'));
       console.log();
       await prompts.waitForEnter();
       return await selectProviderOption(provider);
     }
     
     // Step 6: Let user select model
-    const selectedModel = await selectModelFromList(availableModels, config.name);
+    const selectedModel = await selectModelFromList(models, config.name);
     if (!selectedModel) {
       return await selectProviderOption(provider);
     }

package/src/services/ai/proxy-manager.js

@@ -529,8 +529,10 @@ const submitCallback = async (callbackUrl, provider = 'anthropic') => {
   const config = providerConfig[provider] || providerConfig.anthropic;
   
   // Submit to the provider's OAuth callback port directly
+  // Pass ALL query parameters from the callback URL, not just code and state
+  // Some providers (like Gemini) require additional params like scope, authuser, etc.
   return new Promise((resolve, reject) => {
-    const callbackPath = `${config.path}?code=${encodeURIComponent(code)}&state=${encodeURIComponent(state)}`;
+    const callbackPath = `${config.path}?${url.searchParams.toString()}`;
     
     const req = http.request({
       hostname: '127.0.0.1',
@@ -602,15 +604,32 @@ const waitForAuth = async (state, timeoutMs = 300000, onStatus = () => {}) => {
 
 /**
  * Get available models from the proxy
+ * @param {string} [provider] - Optional provider to filter by (anthropic, openai, google, etc.)
  * @returns {Promise<Array<string>>}
  */
-const getModels = async () => {
+const getModels = async (provider = null) => {
   await ensureRunning();
   
   const response = await proxyRequest('GET', '/v1/models');
   
   if (response.data && Array.isArray(response.data)) {
-    return response.data.map(m => m.id || m).filter(Boolean);
+    let models = response.data;
+    
+    // Filter by provider if specified (using owned_by field from API)
+    if (provider) {
+      // Map our provider IDs to the owned_by values from the API
+      const ownerMap = {
+        anthropic: 'anthropic',
+        openai: 'openai',
+        gemini: 'google',
+        qwen: 'qwen',
+        iflow: 'iflow'
+      };
+      const owner = ownerMap[provider] || provider;
+      models = models.filter(m => m.owned_by && m.owned_by.toLowerCase() === owner.toLowerCase());
+    }
+    
+    return models.map(m => m.id || m).filter(Boolean);
   }
   
   return [];