hedgequantx 2.5.21 → 2.5.23

package/package.json

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

package/src/menus/ai-agent.js

@@ -494,14 +494,39 @@ const showExistingTokens = async () => {
       return await showExistingTokens();
     }
     
-    // Add as new agent
-    const model = provider.defaultModel;
+    spinner.text = 'FETCHING AVAILABLE MODELS...';
+    
+    // Fetch models from API with the token
+    const { fetchAnthropicModels, fetchOpenAIModels } = require('../services/ai/client');
+    
+    let models = null;
+    if (selectedToken.provider === 'anthropic') {
+      models = await fetchAnthropicModels(credentials.apiKey);
+    } else {
+      models = await fetchOpenAIModels(provider.endpoint, credentials.apiKey);
+    }
+    
+    if (!models || models.length === 0) {
+      spinner.fail('COULD NOT FETCH MODELS FROM API');
+      await prompts.waitForEnter();
+      return await showExistingTokens();
+    }
+    
+    spinner.succeed(`FOUND ${models.length} MODELS`);
+    
+    // Let user select model
+    const selectedModel = await selectModelFromList(models, provider.name);
+    if (!selectedModel) {
+      return await showExistingTokens();
+    }
+    
+    // Add agent with selected model
     const agentName = `${provider.name} (${selectedToken.source})`;
-    await aiService.addAgent(selectedToken.provider, 'api_key', credentials, model, agentName);
+    await aiService.addAgent(selectedToken.provider, 'api_key', credentials, selectedModel, agentName);
     
-    spinner.succeed(`AGENT ADDED: ${provider.name}`);
+    console.log(chalk.green(`\n  AGENT ADDED: ${provider.name}`));
     console.log(chalk.gray(`  SOURCE: ${selectedToken.source}`));
-    console.log(chalk.gray(`  MODEL: ${model}`));
+    console.log(chalk.gray(`  MODEL: ${selectedModel}`));
     
     await prompts.waitForEnter();
     return await aiAgentMenu();
@@ -942,8 +967,67 @@ const setupConnection = async (provider, option) => {
   return await aiAgentMenu();
 };
 
+/**
+ * Select model from a list (used when adding new agent)
+ * @param {Array} models - Array of model IDs from API
+ * @param {string} providerName - Provider name for display
+ * @returns {string|null} Selected model ID or null if cancelled
+ * 
+ * Data source: models array comes from provider API (/v1/models)
+ */
+const selectModelFromList = async (models, providerName) => {
+  const boxWidth = getLogoWidth();
+  const W = boxWidth - 2;
+  
+  const makeLine = (content) => {
+    const plainLen = content.replace(/\x1b\[[0-9;]*m/g, '').length;
+    const padding = W - plainLen;
+    return chalk.cyan('║') + ' ' + content + ' '.repeat(Math.max(0, padding - 1)) + chalk.cyan('║');
+  };
+  
+  console.clear();
+  displayBanner();
+  drawBoxHeaderContinue(`SELECT MODEL - ${providerName}`, boxWidth);
+  
+  if (!models || models.length === 0) {
+    console.log(makeLine(chalk.red('NO MODELS AVAILABLE')));
+    console.log(makeLine(chalk.gray('[<] BACK')));
+    drawBoxFooter(boxWidth);
+    await prompts.waitForEnter();
+    return null;
+  }
+  
+  // Sort models (newest first)
+  const sortedModels = [...models].sort((a, b) => b.localeCompare(a));
+  
+  // Display models from API
+  sortedModels.forEach((model, index) => {
+    const displayModel = model.length > W - 10 ? model.substring(0, W - 13) + '...' : model;
+    console.log(makeLine(chalk.cyan(`[${index + 1}] ${displayModel}`)));
+  });
+  
+  console.log(makeLine(''));
+  console.log(makeLine(chalk.gray('[<] BACK')));
+  
+  drawBoxFooter(boxWidth);
+  
+  const choice = await prompts.textInput(chalk.cyan('SELECT MODEL:'));
+  
+  if (choice === '<' || choice?.toLowerCase() === 'b') {
+    return null;
+  }
+  
+  const index = parseInt(choice) - 1;
+  if (isNaN(index) || index < 0 || index >= sortedModels.length) {
+    return await selectModelFromList(models, providerName);
+  }
+  
+  return sortedModels[index];
+};
+
 /**
  * Select/change model for an agent
+ * Fetches available models from the provider's API
  */
 const selectModel = async (agent) => {
   const boxWidth = getLogoWidth();
@@ -959,26 +1043,44 @@ const selectModel = async (agent) => {
   displayBanner();
   drawBoxHeaderContinue(`SELECT MODEL - ${agent.name}`, boxWidth);
   
-  const models = agent.provider?.models || [];
+  console.log(makeLine(chalk.gray('FETCHING AVAILABLE MODELS FROM API...')));
+  drawBoxFooter(boxWidth);
+  
+  // Fetch models from real API
+  const { fetchAnthropicModels, fetchOpenAIModels } = require('../services/ai/client');
+  
+  let models = null;
+  const agentCredentials = aiService.getAgentCredentials(agent.id);
+  
+  if (agent.providerId === 'anthropic') {
+    models = await fetchAnthropicModels(agentCredentials?.apiKey);
+  } else {
+    // OpenAI-compatible providers
+    const endpoint = agentCredentials?.endpoint || agent.provider?.endpoint;
+    models = await fetchOpenAIModels(endpoint, agentCredentials?.apiKey);
+  }
+  
+  // Redraw with results
+  console.clear();
+  displayBanner();
+  drawBoxHeaderContinue(`SELECT MODEL - ${agent.name}`, boxWidth);
   
-  if (models.length === 0) {
-    console.log(makeLine(chalk.gray('NO PREDEFINED MODELS. ENTER MODEL NAME MANUALLY.')));
+  if (!models || models.length === 0) {
+    console.log(makeLine(chalk.red('COULD NOT FETCH MODELS FROM API')));
+    console.log(makeLine(chalk.gray('Check your API key or network connection.')));
     console.log(makeLine(''));
     console.log(makeLine(chalk.gray('[<] BACK')));
     drawBoxFooter(boxWidth);
     
-    const model = await prompts.textInput('ENTER MODEL NAME (OR < TO GO BACK):');
-    if (!model || model === '<') {
-      return await aiAgentMenu();
-    }
-    aiService.updateAgent(agent.id, { model });
-    console.log(chalk.green(`\n  MODEL CHANGED TO: ${model}`));
     await prompts.waitForEnter();
     return await aiAgentMenu();
   }
   
+  // Sort models (newest first typically)
+  models.sort((a, b) => b.localeCompare(a));
+  
+  // Display models from API
   models.forEach((model, index) => {
-    // Truncate long model names
     const displayModel = model.length > W - 10 ? model.substring(0, W - 13) + '...' : model;
     const currentMarker = model === agent.model ? chalk.yellow(' (CURRENT)') : '';
     console.log(makeLine(chalk.cyan(`[${index + 1}] ${displayModel}`) + currentMarker));
@@ -997,7 +1099,7 @@ const selectModel = async (agent) => {
   
   const index = parseInt(choice) - 1;
   if (isNaN(index) || index < 0 || index >= models.length) {
-    return await aiAgentMenu();
+    return await selectModel(agent);
   }
   
   const selectedModel = models[index];

package/src/services/ai/client.js

@@ -272,10 +272,72 @@ Analyze and provide recommendation.`;
   }
 };
 
+/**
+ * Fetch available models from Anthropic API
+ * @param {string} apiKey - API key
+ * @returns {Promise<Array|null>} Array of model IDs or null on error
+ * 
+ * Data source: https://api.anthropic.com/v1/models (GET)
+ */
+const fetchAnthropicModels = async (apiKey) => {
+  if (!apiKey) return null;
+  
+  const url = 'https://api.anthropic.com/v1/models';
+  
+  const headers = {
+    'x-api-key': apiKey,
+    'anthropic-version': '2023-06-01'
+  };
+  
+  try {
+    const response = await makeRequest(url, { method: 'GET', headers, timeout: 10000 });
+    if (response.data && Array.isArray(response.data)) {
+      return response.data.map(m => m.id).filter(Boolean);
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+};
+
+/**
+ * Fetch available models from OpenAI-compatible API
+ * @param {string} endpoint - API endpoint
+ * @param {string} apiKey - API key
+ * @returns {Promise<Array|null>} Array of model IDs or null on error
+ * 
+ * Data source: {endpoint}/models (GET)
+ */
+const fetchOpenAIModels = async (endpoint, apiKey) => {
+  if (!endpoint) return null;
+  
+  const url = `${endpoint}/models`;
+  
+  const headers = {
+    'Content-Type': 'application/json'
+  };
+  
+  if (apiKey) {
+    headers['Authorization'] = `Bearer ${apiKey}`;
+  }
+  
+  try {
+    const response = await makeRequest(url, { method: 'GET', headers, timeout: 10000 });
+    if (response.data && Array.isArray(response.data)) {
+      return response.data.map(m => m.id).filter(Boolean);
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+};
+
 module.exports = {
   callAI,
   analyzeTrading,
   callOpenAICompatible,
   callAnthropic,
-  callGemini
+  callGemini,
+  fetchAnthropicModels,
+  fetchOpenAIModels
 };

package/src/services/ai/index.js

@@ -159,6 +159,20 @@ const getAgent = (agentId) => {
   };
 };
 
+/**
+ * Get agent credentials by ID
+ * @param {string} agentId - Agent ID
+ * @returns {Object|null} Credentials object or null
+ */
+const getAgentCredentials = (agentId) => {
+  const aiSettings = getAISettings();
+  const agents = aiSettings.agents || [];
+  const agent = agents.find(a => a.id === agentId);
+  
+  if (!agent) return null;
+  return agent.credentials || null;
+};
+
 /**
  * Set active agent
  */
@@ -607,6 +621,7 @@ module.exports = {
   getAgents,
   getAgentCount,
   getAgent,
+  getAgentCredentials,
   getActiveAgent,
   setActiveAgent,
   addAgent,

package/src/services/ai/providers/index.js

@@ -43,16 +43,8 @@ const PROVIDERS = {
     name: 'CLAUDE (ANTHROPIC)',
     description: 'Direct connection to Claude',
     category: 'direct',
-    models: [
-      'claude-opus-4-20250514',           // Claude Opus 4 (latest flagship)
-      'claude-sonnet-4-20250514',         // Claude Sonnet 4
-      'claude-sonnet-4-5-20250929',       // Claude Sonnet 4.5 (extended thinking)
-      'claude-3-5-sonnet-20241022',       // Claude 3.5 Sonnet v2
-      'claude-3-5-haiku-20241022',        // Claude 3.5 Haiku
-      'claude-3-opus-20240229',           // Claude 3 Opus
-      'claude-3-haiku-20240307'           // Claude 3 Haiku
-    ],
-    defaultModel: 'claude-sonnet-4-20250514',
+    models: [], // Fetched from API at runtime
+    defaultModel: null, // Will use first model from API
     options: [
       {
         id: 'api_key',