hedgequantx 2.7.20 → 2.7.21

package/package.json

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

package/src/pages/ai-agents.js

@@ -10,9 +10,10 @@ const os = require('os');
 const path = require('path');
 const fs = require('fs');
 
+const ora = require('ora');
 const { getLogoWidth, centerText, visibleLength } = require('../ui');
 const { prompts } = require('../utils');
-const { getModelsForProvider, getModelById } = require('./ai-models');
+const { fetchModelsFromApi } = require('./ai-models');
 
 // Config file path
 const CONFIG_DIR = path.join(os.homedir(), '.hqx');
@@ -135,18 +136,27 @@ const drawModelsTable = (provider, models, boxWidth) => {
 };
 
 /**
- * Select a model for a provider
+ * Select a model for a provider (fetches from API)
  * @param {Object} provider - Provider object
- * @returns {Object|null} Selected model or null if cancelled
+ * @param {string} apiKey - API key for fetching models
+ * @returns {Object|null} Selected model or null if cancelled/failed
  */
-const selectModel = async (provider) => {
+const selectModel = async (provider, apiKey) => {
   const boxWidth = getLogoWidth();
-  const models = getModelsForProvider(provider.id);
   
-  if (models.length === 0) {
+  // Fetch models from API
+  const spinner = ora({ text: 'Fetching models from API...', color: 'yellow' }).start();
+  const result = await fetchModelsFromApi(provider.id, apiKey);
+  
+  if (!result.success || result.models.length === 0) {
+    spinner.fail(result.error || 'No models available');
+    await prompts.waitForEnter();
     return null;
   }
   
+  spinner.succeed(`Found ${result.models.length} models`);
+  const models = result.models;
+  
   while (true) {
     console.clear();
     drawModelsTable(provider, models, boxWidth);
@@ -294,9 +304,11 @@ const handleProviderConfig = async (provider, config) => {
     }
     
     if (choice === '1') {
-      // CLIProxy connection - select model first
-      const selectedModel = await selectModel(provider);
-      if (!selectedModel) continue;
+      // CLIProxy connection - models will be fetched via proxy
+      console.log();
+      console.log(chalk.cyan('  CLIProxy uses your paid plan subscription.'));
+      console.log(chalk.gray('  Model selection will be available after connecting.'));
+      console.log();
       
       // Deactivate all other providers
       Object.keys(config.providers).forEach(id => {
@@ -305,26 +317,22 @@ const handleProviderConfig = async (provider, config) => {
       
       if (!config.providers[provider.id]) config.providers[provider.id] = {};
       config.providers[provider.id].connectionType = 'cliproxy';
-      config.providers[provider.id].modelId = selectedModel.id;
-      config.providers[provider.id].modelName = selectedModel.name;
+      config.providers[provider.id].modelId = null;
+      config.providers[provider.id].modelName = 'N/A';
       config.providers[provider.id].active = true;
       config.providers[provider.id].configuredAt = new Date().toISOString();
       
       if (saveConfig(config)) {
-        console.log(chalk.green(`\n  ✓ ${provider.name} connected via CLIProxy.`));
-        console.log(chalk.cyan(`    Model: ${selectedModel.name}`));
+        console.log(chalk.green(`  ✓ ${provider.name} connected via CLIProxy.`));
       } else {
-        console.log(chalk.red('\n  Failed to save config.'));
+        console.log(chalk.red('  Failed to save config.'));
       }
       await prompts.waitForEnter();
       continue;
     }
     
     if (choice === '2') {
-      // API Key connection - select model first
-      const selectedModel = await selectModel(provider);
-      if (!selectedModel) continue;
-      
+      // API Key connection - get key first, then fetch models
       console.clear();
       console.log(chalk.yellow(`\n  Enter your ${provider.name} API key:`));
       console.log(chalk.gray('  (Press Enter to cancel)'));
@@ -344,6 +352,10 @@ const handleProviderConfig = async (provider, config) => {
         continue;
       }
       
+      // Fetch models from API with the provided key
+      const selectedModel = await selectModel(provider, apiKey.trim());
+      if (!selectedModel) continue;
+      
       // Deactivate all other providers
       Object.keys(config.providers).forEach(id => {
         if (config.providers[id]) config.providers[id].active = false;

package/src/pages/ai-models.js

@@ -1,84 +1,224 @@
 /**
- * AI Models Configuration
+ * AI Models - Fetch from provider APIs
  * 
- * Lists available models for each AI provider.
- * These are technical configuration values, not trading data.
+ * Models are fetched dynamically from each provider's API.
+ * No hardcoded model lists - data comes from real APIs only.
  */
 
-// Models by provider ID
-const PROVIDER_MODELS = {
-  anthropic: [
-    { id: 'claude-opus-4-20250514', name: 'Claude Opus 4', tier: 'flagship' },
-    { id: 'claude-sonnet-4-20250514', name: 'Claude Sonnet 4', tier: 'balanced' },
-    { id: 'claude-3-5-sonnet-20241022', name: 'Claude Sonnet 3.5', tier: 'balanced' },
-    { id: 'claude-3-5-haiku-20241022', name: 'Claude Haiku 3.5', tier: 'fast' },
-  ],
-  openai: [
-    { id: 'gpt-4o', name: 'GPT-4o', tier: 'flagship' },
-    { id: 'gpt-4o-mini', name: 'GPT-4o Mini', tier: 'fast' },
-    { id: 'gpt-4-turbo', name: 'GPT-4 Turbo', tier: 'balanced' },
-    { id: 'o1', name: 'o1', tier: 'reasoning' },
-    { id: 'o1-mini', name: 'o1-mini', tier: 'reasoning' },
-    { id: 'o3-mini', name: 'o3-mini', tier: 'reasoning' },
-  ],
-  google: [
-    { id: 'gemini-2.0-flash', name: 'Gemini 2.0 Flash', tier: 'flagship' },
-    { id: 'gemini-1.5-pro', name: 'Gemini 1.5 Pro', tier: 'balanced' },
-    { id: 'gemini-1.5-flash', name: 'Gemini 1.5 Flash', tier: 'fast' },
-    { id: 'gemini-1.0-pro', name: 'Gemini 1.0 Pro', tier: 'legacy' },
-  ],
-  mistral: [
-    { id: 'mistral-large-latest', name: 'Mistral Large', tier: 'flagship' },
-    { id: 'mistral-medium-latest', name: 'Mistral Medium', tier: 'balanced' },
-    { id: 'mistral-small-latest', name: 'Mistral Small', tier: 'fast' },
-    { id: 'codestral-latest', name: 'Codestral', tier: 'code' },
-  ],
-  groq: [
-    { id: 'llama-3.3-70b-versatile', name: 'Llama 3.3 70B', tier: 'flagship' },
-    { id: 'llama-3.1-8b-instant', name: 'Llama 3.1 8B', tier: 'fast' },
-    { id: 'mixtral-8x7b-32768', name: 'Mixtral 8x7B', tier: 'balanced' },
-    { id: 'gemma2-9b-it', name: 'Gemma 2 9B', tier: 'fast' },
-  ],
-  xai: [
-    { id: 'grok-2', name: 'Grok 2', tier: 'flagship' },
-    { id: 'grok-2-mini', name: 'Grok 2 Mini', tier: 'fast' },
-    { id: 'grok-beta', name: 'Grok Beta', tier: 'beta' },
-  ],
-  perplexity: [
-    { id: 'sonar-pro', name: 'Sonar Pro', tier: 'flagship' },
-    { id: 'sonar', name: 'Sonar', tier: 'balanced' },
-    { id: 'sonar-reasoning', name: 'Sonar Reasoning', tier: 'reasoning' },
-  ],
-  openrouter: [
-    { id: 'anthropic/claude-opus-4', name: 'Claude Opus 4', tier: 'flagship' },
-    { id: 'openai/gpt-4o', name: 'GPT-4o', tier: 'flagship' },
-    { id: 'google/gemini-2.0-flash', name: 'Gemini 2.0 Flash', tier: 'flagship' },
-    { id: 'meta-llama/llama-3.3-70b', name: 'Llama 3.3 70B', tier: 'open' },
-  ],
+const https = require('https');
+
+/**
+ * API endpoints for fetching models
+ */
+const API_ENDPOINTS = {
+  anthropic: 'https://api.anthropic.com/v1/models',
+  openai: 'https://api.openai.com/v1/models',
+  google: 'https://generativelanguage.googleapis.com/v1/models',
+  mistral: 'https://api.mistral.ai/v1/models',
+  groq: 'https://api.groq.com/openai/v1/models',
+  xai: 'https://api.x.ai/v1/models',
+  perplexity: 'https://api.perplexity.ai/models',
+  openrouter: 'https://openrouter.ai/api/v1/models',
+};
+
+/**
+ * Make HTTPS request
+ * @param {string} url - API URL
+ * @param {Object} headers - Request headers
+ * @param {number} timeout - Timeout in ms (default 60000 per RULES.md #15)
+ * @returns {Promise<Object>} Response data
+ */
+const fetchApi = (url, headers = {}, timeout = 60000) => {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    const options = {
+      hostname: urlObj.hostname,
+      path: urlObj.pathname + urlObj.search,
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        ...headers
+      },
+      timeout
+    };
+
+    const req = https.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            resolve({ success: true, data: JSON.parse(data) });
+          } else {
+            resolve({ success: false, error: `HTTP ${res.statusCode}` });
+          }
+        } catch (error) {
+          resolve({ success: false, error: 'Invalid JSON response' });
+        }
+      });
+    });
+
+    req.on('error', (error) => {
+      resolve({ success: false, error: error.message });
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      resolve({ success: false, error: 'Request timeout' });
+    });
+
+    req.end();
+  });
 };
 
 /**
- * Get models for a provider
+ * Get auth headers for provider
  * @param {string} providerId - Provider ID
- * @returns {Array} List of models
+ * @param {string} apiKey - API key
+ * @returns {Object} Headers object
  */
-const getModelsForProvider = (providerId) => {
-  return PROVIDER_MODELS[providerId] || [];
+const getAuthHeaders = (providerId, apiKey) => {
+  if (!apiKey) return {};
+  
+  switch (providerId) {
+    case 'anthropic':
+      return { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' };
+    case 'openai':
+    case 'groq':
+    case 'xai':
+    case 'perplexity':
+    case 'openrouter':
+      return { 'Authorization': `Bearer ${apiKey}` };
+    case 'google':
+      return {}; // Google uses query param
+    case 'mistral':
+      return { 'Authorization': `Bearer ${apiKey}` };
+    default:
+      return { 'Authorization': `Bearer ${apiKey}` };
+  }
 };
 
 /**
- * Get model by ID
+ * Parse models response based on provider
  * @param {string} providerId - Provider ID
+ * @param {Object} data - API response data
+ * @returns {Array} Parsed models list
+ */
+const parseModelsResponse = (providerId, data) => {
+  if (!data) return [];
+  
+  try {
+    switch (providerId) {
+      case 'anthropic':
+        // Anthropic returns { data: [{ id, display_name, ... }] }
+        return (data.data || []).map(m => ({
+          id: m.id,
+          name: m.display_name || m.id
+        }));
+      
+      case 'openai':
+      case 'groq':
+      case 'xai':
+        // OpenAI format: { data: [{ id, ... }] }
+        return (data.data || [])
+          .filter(m => m.id && !m.id.includes('whisper') && !m.id.includes('tts') && !m.id.includes('dall-e'))
+          .map(m => ({
+            id: m.id,
+            name: m.id
+          }));
+      
+      case 'google':
+        // Google format: { models: [{ name, displayName, ... }] }
+        return (data.models || []).map(m => ({
+          id: m.name?.replace('models/', '') || m.name,
+          name: m.displayName || m.name
+        }));
+      
+      case 'mistral':
+        // Mistral format: { data: [{ id, ... }] }
+        return (data.data || []).map(m => ({
+          id: m.id,
+          name: m.id
+        }));
+      
+      case 'perplexity':
+        // Perplexity format varies
+        return (data.models || data.data || []).map(m => ({
+          id: m.id || m.model,
+          name: m.id || m.model
+        }));
+      
+      case 'openrouter':
+        // OpenRouter format: { data: [{ id, name, ... }] }
+        return (data.data || []).map(m => ({
+          id: m.id,
+          name: m.name || m.id
+        }));
+      
+      default:
+        return [];
+    }
+  } catch (error) {
+    return [];
+  }
+};
+
+/**
+ * Fetch models from provider API
+ * @param {string} providerId - Provider ID
+ * @param {string} apiKey - API key (required for most providers)
+ * @returns {Promise<Object>} { success, models, error }
+ */
+const fetchModelsFromApi = async (providerId, apiKey) => {
+  const endpoint = API_ENDPOINTS[providerId];
+  if (!endpoint) {
+    return { success: false, models: [], error: 'Unknown provider' };
+  }
+  
+  // Build URL (Google needs API key in query)
+  let url = endpoint;
+  if (providerId === 'google' && apiKey) {
+    url += `?key=${apiKey}`;
+  }
+  
+  const headers = getAuthHeaders(providerId, apiKey);
+  const result = await fetchApi(url, headers);
+  
+  if (!result.success) {
+    return { success: false, models: [], error: result.error };
+  }
+  
+  const models = parseModelsResponse(providerId, result.data);
+  
+  if (models.length === 0) {
+    return { success: false, models: [], error: 'No models returned' };
+  }
+  
+  return { success: true, models, error: null };
+};
+
+/**
+ * Get models for a provider - returns empty, use fetchModelsFromApi
+ * @param {string} providerId - Provider ID
+ * @returns {Array} Empty array
+ */
+const getModelsForProvider = (providerId) => {
+  return [];
+};
+
+/**
+ * Get model by ID - returns null, use API data
+ * @param {string} providerId - Provider ID  
  * @param {string} modelId - Model ID
- * @returns {Object|null} Model object or null
+ * @returns {null} Always null
  */
 const getModelById = (providerId, modelId) => {
-  const models = PROVIDER_MODELS[providerId] || [];
-  return models.find(m => m.id === modelId) || null;
+  return null;
 };
 
 module.exports = {
-  PROVIDER_MODELS,
+  fetchModelsFromApi,
   getModelsForProvider,
-  getModelById
+  getModelById,
+  API_ENDPOINTS
 };