hedgequantx 2.4.44 → 2.5.1

package/README.md

@@ -208,7 +208,7 @@ Mirror trades from Lead to Follower accounts.
 <div align="center">
 
 [![Discord](https://img.shields.io/badge/Discord-Join%20Server-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/UBKCERctZu)
-[![GitHub Issues](https://img.shields.io/badge/GitHub-Issues-181717?style=for-the-badge&logo=github&logoColor=white)](https://github.com/HedgeQuantX/HQX-CLI/issues)
+[![GitHub Issues](https://img.shields.io/badge/GitHub-Issues-181717?style=for-the-badge&logo=github&logoColor=white)](https://github.com/HedgeQuantX/HedgeQuantX/issues)
 
 </div>
 

package/package.json

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

package/src/app.js

@@ -27,6 +27,7 @@ const {
   dashboardMenu,
   handleUpdate,
 } = require('./menus');
+const { aiAgentMenu } = require('./menus/ai-agent');
 
 /** @type {Object|null} */
 let currentService = null;
@@ -336,6 +337,10 @@ const run = async () => {
               }
               break;
 
+            case 'ai_agent':
+              await aiAgentMenu();
+              break;
+
             case 'update':
               await handleUpdate();
               break;

package/src/menus/ai-agent.js

@@ -0,0 +1,406 @@
+/**
+ * AI Agent Menu
+ * Configure AI provider connection
+ */
+
+const chalk = require('chalk');
+const ora = require('ora');
+
+const { getLogoWidth, drawBoxHeader, drawBoxFooter } = require('../ui');
+const { prompts } = require('../utils');
+const aiService = require('../services/ai');
+const { getCategories, getProvidersByCategory } = require('../services/ai/providers');
+
+/**
+ * Main AI Agent menu
+ */
+const aiAgentMenu = async () => {
+  const boxWidth = getLogoWidth();
+  const W = boxWidth - 2;
+  
+  const makeLine = (content, align = 'left') => {
+    const plainLen = content.replace(/\x1b\[[0-9;]*m/g, '').length;
+    const padding = W - plainLen;
+    if (align === 'center') {
+      const leftPad = Math.floor(padding / 2);
+      return chalk.cyan('║') + ' '.repeat(leftPad) + content + ' '.repeat(padding - leftPad) + chalk.cyan('║');
+    }
+    return chalk.cyan('║') + ' ' + content + ' '.repeat(Math.max(0, padding - 1)) + chalk.cyan('║');
+  };
+  
+  console.clear();
+  drawBoxHeader('AI AGENT', boxWidth);
+  
+  // Show current status
+  const connection = aiService.getConnection();
+  
+  if (connection) {
+    console.log(makeLine(chalk.green('STATUS: ● CONNECTED'), 'left'));
+    console.log(makeLine(chalk.white(`PROVIDER: ${connection.provider.name}`), 'left'));
+    console.log(makeLine(chalk.white(`MODEL: ${connection.model}`), 'left'));
+  } else {
+    console.log(makeLine(chalk.gray('STATUS: ○ NOT CONNECTED'), 'left'));
+  }
+  
+  console.log(chalk.cyan('╠' + '═'.repeat(W) + '╣'));
+  
+  // Menu options
+  const options = [];
+  
+  if (!connection) {
+    options.push({ label: chalk.green('[1] CONNECT PROVIDER'), value: 'connect' });
+  } else {
+    options.push({ label: chalk.cyan('[1] CHANGE PROVIDER'), value: 'connect' });
+    options.push({ label: chalk.yellow('[2] CHANGE MODEL'), value: 'model' });
+    options.push({ label: chalk.red('[3] DISCONNECT'), value: 'disconnect' });
+  }
+  options.push({ label: chalk.gray('[<] BACK'), value: 'back' });
+  
+  for (const opt of options) {
+    console.log(makeLine(opt.label, 'left'));
+  }
+  
+  drawBoxFooter(boxWidth);
+  
+  const choice = await prompts.textInput(chalk.cyan('SELECT:'));
+  
+  switch (choice?.toLowerCase()) {
+    case '1':
+      return await selectCategory();
+    case '2':
+      if (connection) {
+        return await selectModel(connection.provider);
+      }
+      return;
+    case '3':
+      if (connection) {
+        aiService.disconnect();
+        console.log(chalk.yellow('\n  AI AGENT DISCONNECTED'));
+        await prompts.waitForEnter();
+      }
+      return;
+    case '<':
+    case 'b':
+      return;
+    default:
+      return;
+  }
+};
+
+/**
+ * Select provider category
+ */
+const selectCategory = async () => {
+  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();
+  drawBoxHeader('SELECT PROVIDER TYPE', boxWidth);
+  
+  const categories = getCategories();
+  
+  categories.forEach((cat, index) => {
+    const color = cat.id === 'unified' ? chalk.green : 
+                  cat.id === 'local' ? chalk.yellow : chalk.cyan;
+    console.log(makeLine(color(`[${index + 1}] ${cat.name}`)));
+    console.log(makeLine(chalk.gray('    ' + cat.description)));
+    console.log(makeLine(''));
+  });
+  
+  console.log(makeLine(chalk.gray('[<] BACK')));
+  
+  drawBoxFooter(boxWidth);
+  
+  const choice = await prompts.textInput(chalk.cyan('SELECT (1-4):'));
+  
+  if (choice === '<' || choice?.toLowerCase() === 'b') {
+    return await aiAgentMenu();
+  }
+  
+  const index = parseInt(choice) - 1;
+  if (isNaN(index) || index < 0 || index >= categories.length) {
+    return await aiAgentMenu();
+  }
+  
+  const selectedCategory = categories[index];
+  return await selectProvider(selectedCategory.id);
+};
+
+/**
+ * Select AI provider from category
+ */
+const selectProvider = async (categoryId) => {
+  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();
+  
+  const categories = getCategories();
+  const category = categories.find(c => c.id === categoryId);
+  drawBoxHeader(category.name, boxWidth);
+  
+  const providers = getProvidersByCategory(categoryId);
+  
+  if (providers.length === 0) {
+    console.log(makeLine(chalk.gray('No providers in this category')));
+    drawBoxFooter(boxWidth);
+    await prompts.waitForEnter();
+    return await selectCategory();
+  }
+  
+  // Display providers
+  providers.forEach((provider, index) => {
+    const isRecommended = provider.id === 'openrouter';
+    const color = isRecommended ? chalk.green : chalk.cyan;
+    console.log(makeLine(color(`[${index + 1}] ${provider.name}`)));
+    console.log(makeLine(chalk.gray('    ' + provider.description)));
+    if (provider.models && provider.models.length > 0) {
+      const modelList = provider.models.slice(0, 3).join(', ');
+      console.log(makeLine(chalk.gray('    Models: ' + modelList + (provider.models.length > 3 ? '...' : ''))));
+    }
+    console.log(makeLine(''));
+  });
+  
+  console.log(makeLine(chalk.gray('[<] BACK')));
+  
+  drawBoxFooter(boxWidth);
+  
+  const choice = await prompts.textInput(chalk.cyan('SELECT PROVIDER:'));
+  
+  if (choice === '<' || choice?.toLowerCase() === 'b') {
+    return await selectCategory();
+  }
+  
+  const index = parseInt(choice) - 1;
+  if (isNaN(index) || index < 0 || index >= providers.length) {
+    return await selectCategory();
+  }
+  
+  const selectedProvider = providers[index];
+  return await selectProviderOption(selectedProvider);
+};
+
+/**
+ * Select connection option for provider
+ */
+const selectProviderOption = async (provider) => {
+  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('║');
+  };
+  
+  // If only one option, skip selection
+  if (provider.options.length === 1) {
+    return await setupConnection(provider, provider.options[0]);
+  }
+  
+  console.clear();
+  drawBoxHeader(provider.name, boxWidth);
+  
+  console.log(makeLine(chalk.white('SELECT CONNECTION METHOD:')));
+  console.log(makeLine(''));
+  
+  provider.options.forEach((option, index) => {
+    console.log(makeLine(chalk.cyan(`[${index + 1}] ${option.label}`)));
+    option.description.forEach(desc => {
+      console.log(makeLine(chalk.gray('    ' + desc)));
+    });
+    console.log(makeLine(''));
+  });
+  
+  console.log(makeLine(chalk.gray('[<] BACK')));
+  
+  drawBoxFooter(boxWidth);
+  
+  const choice = await prompts.textInput(chalk.cyan('SELECT:'));
+  
+  if (choice === '<' || choice?.toLowerCase() === 'b') {
+    return await selectProvider(provider.category);
+  }
+  
+  const index = parseInt(choice) - 1;
+  if (isNaN(index) || index < 0 || index >= provider.options.length) {
+    return await selectProvider(provider.category);
+  }
+  
+  const selectedOption = provider.options[index];
+  return await setupConnection(provider, selectedOption);
+};
+
+/**
+ * Setup connection with credentials
+ */
+const setupConnection = async (provider, option) => {
+  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();
+  drawBoxHeader(`CONNECT TO ${provider.name}`, boxWidth);
+  
+  // Show instructions
+  if (option.url) {
+    console.log(makeLine(chalk.white('GET YOUR CREDENTIALS:')));
+    console.log(makeLine(chalk.cyan(option.url)));
+    console.log(makeLine(''));
+  }
+  
+  drawBoxFooter(boxWidth);
+  console.log();
+  
+  // Collect credentials based on fields
+  const credentials = {};
+  
+  for (const field of option.fields) {
+    let value;
+    
+    switch (field) {
+      case 'apiKey':
+        value = await prompts.passwordInput('ENTER API KEY:');
+        if (!value) return await selectProviderOption(provider);
+        credentials.apiKey = value;
+        break;
+        
+      case 'sessionKey':
+        value = await prompts.passwordInput('ENTER SESSION KEY:');
+        if (!value) return await selectProviderOption(provider);
+        credentials.sessionKey = value;
+        break;
+        
+      case 'accessToken':
+        value = await prompts.passwordInput('ENTER ACCESS TOKEN:');
+        if (!value) return await selectProviderOption(provider);
+        credentials.accessToken = value;
+        break;
+        
+      case 'endpoint':
+        const defaultEndpoint = option.defaultEndpoint || '';
+        value = await prompts.textInput(`ENDPOINT [${defaultEndpoint || 'required'}]:`);
+        credentials.endpoint = value || defaultEndpoint;
+        if (!credentials.endpoint) return await selectProviderOption(provider);
+        break;
+        
+      case 'model':
+        value = await prompts.textInput('MODEL NAME:');
+        if (!value) return await selectProviderOption(provider);
+        credentials.model = value;
+        break;
+    }
+  }
+  
+  // Validate connection
+  const spinner = ora({ text: 'VALIDATING CONNECTION...', color: 'cyan' }).start();
+  
+  const validation = await aiService.validateConnection(provider.id, option.id, credentials);
+  
+  if (!validation.valid) {
+    spinner.fail(`CONNECTION FAILED: ${validation.error}`);
+    await prompts.waitForEnter();
+    return await selectProviderOption(provider);
+  }
+  
+  // Save connection
+  try {
+    const model = credentials.model || provider.defaultModel;
+    await aiService.connect(provider.id, option.id, credentials, model);
+    spinner.succeed(`CONNECTED TO ${provider.name}`);
+    
+    // Show available models for local providers
+    if (validation.models && validation.models.length > 0) {
+      console.log(chalk.gray(`  AVAILABLE MODELS: ${validation.models.slice(0, 5).join(', ')}`));
+    }
+    
+    console.log(chalk.gray(`  USING MODEL: ${model}`));
+  } catch (error) {
+    spinner.fail(`FAILED TO SAVE: ${error.message}`);
+  }
+  
+  await prompts.waitForEnter();
+  return await aiAgentMenu();
+};
+
+/**
+ * Select/change model for current provider
+ */
+const selectModel = async (provider) => {
+  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();
+  drawBoxHeader('SELECT MODEL', boxWidth);
+  
+  const models = provider.models || [];
+  
+  if (models.length === 0) {
+    console.log(makeLine(chalk.gray('No predefined models. Enter model name manually.')));
+    drawBoxFooter(boxWidth);
+    
+    const model = await prompts.textInput('ENTER MODEL NAME:');
+    if (model) {
+      const settings = aiService.getAISettings();
+      settings.model = model;
+      aiService.saveAISettings(settings);
+      console.log(chalk.green(`\n  MODEL CHANGED TO: ${model}`));
+    }
+    await prompts.waitForEnter();
+    return await aiAgentMenu();
+  }
+  
+  models.forEach((model, index) => {
+    console.log(makeLine(chalk.cyan(`[${index + 1}] ${model}`)));
+  });
+  
+  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 await aiAgentMenu();
+  }
+  
+  const index = parseInt(choice) - 1;
+  if (isNaN(index) || index < 0 || index >= models.length) {
+    return await aiAgentMenu();
+  }
+  
+  const selectedModel = models[index];
+  const settings = aiService.getAISettings();
+  settings.model = selectedModel;
+  aiService.saveAISettings(settings);
+  
+  console.log(chalk.green(`\n  MODEL CHANGED TO: ${selectedModel}`));
+  await prompts.waitForEnter();
+  return await aiAgentMenu();
+};
+
+module.exports = { aiAgentMenu };

package/src/menus/dashboard.js

@@ -10,6 +10,7 @@ const { connections } = require('../services');
 const { getLogoWidth, centerText, prepareStdin } = require('../ui');
 const { getCachedStats } = require('../services/stats-cache');
 const { prompts } = require('../utils');
+const aiService = require('../services/ai');
 
 /**
  * Dashboard menu after login
@@ -60,9 +61,18 @@ const dashboardMenu = async (service) => {
       pnlDisplay = '--';
     }
     
+    // AI status
+    const aiConnection = aiService.getConnection();
+    const aiStatus = aiConnection 
+      ? aiConnection.provider.name.split(' ')[0]  // Just "CLAUDE" or "OPENAI"
+      : null;
+    
     // Yellow icons: ✔ for each stat
     const icon = chalk.yellow('✔ ');
-    const statsPlain = `✔ CONNECTIONS: ${statsInfo.connections}    ✔ ACCOUNTS: ${statsInfo.accounts}    ✔ BALANCE: ${balStr}    ✔ P&L: ${pnlDisplay}`;
+    const aiIcon = aiStatus ? chalk.magenta('✔ ') : chalk.gray('○ ');
+    const aiText = aiStatus ? chalk.magenta(aiStatus) : chalk.gray('NONE');
+    
+    const statsPlain = `✔ CONNECTIONS: ${statsInfo.connections}    ✔ ACCOUNTS: ${statsInfo.accounts}    ✔ BALANCE: ${balStr}    AI: ${aiStatus || 'NONE'}`;
     const statsLeftPad = Math.max(0, Math.floor((W - statsPlain.length) / 2));
     const statsRightPad = Math.max(0, W - statsPlain.length - statsLeftPad);
     
@@ -70,7 +80,7 @@ const dashboardMenu = async (service) => {
       icon + chalk.white(`CONNECTIONS: ${statsInfo.connections}`) + '    ' +
       icon + chalk.white(`ACCOUNTS: ${statsInfo.accounts}`) + '    ' +
       icon + chalk.white('BALANCE: ') + balColor(balStr) + '    ' +
-      icon + chalk.white('P&L: ') + pnlColor(pnlDisplay) +
+      aiIcon + chalk.white('AI: ') + aiText +
       ' '.repeat(Math.max(0, statsRightPad)) + chalk.cyan('║'));
   }
   
@@ -87,19 +97,21 @@ const dashboardMenu = async (service) => {
   };
   
   menuRow(chalk.cyan('[1] VIEW ACCOUNTS'), chalk.cyan('[2] VIEW STATS'));
-  menuRow(chalk.cyan('[+] ADD PROP-ACCOUNT'), chalk.magenta('[A] ALGO-TRADING'));
-  menuRow(chalk.yellow('[U] UPDATE HQX'), chalk.red('[X] DISCONNECT'));
+  menuRow(chalk.cyan('[+] ADD PROP-ACCOUNT'), chalk.magenta('[A] ALGO TRADING'));
+  menuRow(chalk.magenta('[I] AI AGENT'), chalk.yellow('[U] UPDATE HQX'));
+  menuRow(chalk.red('[X] DISCONNECT'), '');
   
   console.log(chalk.cyan('╚' + '═'.repeat(W) + '╝'));
   
   // Simple input - no duplicate menu
-  const input = await prompts.textInput(chalk.cyan('SELECT (1/2/+/A/U/X)'));
+  const input = await prompts.textInput(chalk.cyan('SELECT (1/2/+/A/I/U/X)'));
   
   const actionMap = {
     '1': 'accounts',
     '2': 'stats',
     '+': 'add_prop_account',
     'a': 'algotrading',
+    'i': 'ai_agent',
     'u': 'update',
     'x': 'disconnect'
   };

package/src/services/ai/index.js

@@ -0,0 +1,371 @@
+/**
+ * AI Service Manager
+ * Manages AI provider connections and settings
+ */
+
+const { getProviders, getProvider } = require('./providers');
+const { settings } = require('../../config');
+
+// In-memory cache of current connection
+let currentConnection = null;
+
+/**
+ * Get AI settings from storage
+ */
+const getAISettings = () => {
+  try {
+    return settings.get('ai') || {};
+  } catch {
+    return {};
+  }
+};
+
+/**
+ * Save AI settings to storage
+ */
+const saveAISettings = (aiSettings) => {
+  try {
+    settings.set('ai', aiSettings);
+  } catch (e) {
+    // Silent fail
+  }
+};
+
+/**
+ * Check if AI is connected
+ */
+const isConnected = () => {
+  const aiSettings = getAISettings();
+  return !!(aiSettings.provider && aiSettings.credentials);
+};
+
+/**
+ * Get current connection info
+ */
+const getConnection = () => {
+  const aiSettings = getAISettings();
+  if (!aiSettings.provider) return null;
+  
+  const provider = getProvider(aiSettings.provider);
+  if (!provider) return null;
+  
+  return {
+    provider: provider,
+    option: aiSettings.option,
+    model: aiSettings.model || provider.defaultModel,
+    connected: true
+  };
+};
+
+/**
+ * Connect to a provider
+ */
+const connect = async (providerId, optionId, credentials, model = null) => {
+  const provider = getProvider(providerId);
+  if (!provider) {
+    throw new Error('Invalid provider');
+  }
+  
+  const option = provider.options.find(o => o.id === optionId);
+  if (!option) {
+    throw new Error('Invalid option');
+  }
+  
+  // Save to settings
+  const aiSettings = {
+    provider: providerId,
+    option: optionId,
+    credentials: credentials,
+    model: model || provider.defaultModel
+  };
+  
+  saveAISettings(aiSettings);
+  currentConnection = getConnection();
+  
+  return currentConnection;
+};
+
+/**
+ * Disconnect from AI
+ */
+const disconnect = () => {
+  saveAISettings({});
+  currentConnection = null;
+};
+
+/**
+ * Get credentials (for API calls)
+ */
+const getCredentials = () => {
+  const aiSettings = getAISettings();
+  return aiSettings.credentials || null;
+};
+
+/**
+ * Validate API key with provider
+ */
+const validateConnection = async (providerId, optionId, credentials) => {
+  const provider = getProvider(providerId);
+  if (!provider) return { valid: false, error: 'Invalid provider' };
+  
+  try {
+    switch (providerId) {
+      case 'anthropic':
+        return await validateAnthropic(credentials);
+      case 'openai':
+        return await validateOpenAI(credentials);
+      case 'gemini':
+        return await validateGemini(credentials);
+      case 'deepseek':
+        return await validateDeepSeek(credentials);
+      case 'groq':
+        return await validateGroq(credentials);
+      case 'ollama':
+        return await validateOllama(credentials);
+      case 'lmstudio':
+        return await validateLMStudio(credentials);
+      case 'custom':
+        return await validateCustom(credentials);
+      // OpenAI-compatible providers (use same validation)
+      case 'openrouter':
+        return await validateOpenRouter(credentials);
+      case 'xai':
+      case 'mistral':
+      case 'perplexity':
+      case 'together':
+      case 'qwen':
+      case 'moonshot':
+      case 'yi':
+      case 'zhipu':
+      case 'baichuan':
+        return await validateOpenAICompatible(provider, credentials);
+      default:
+        return { valid: false, error: 'Unknown provider' };
+    }
+  } catch (error) {
+    return { valid: false, error: error.message };
+  }
+};
+
+// Validation functions for each provider
+const validateAnthropic = async (credentials) => {
+  try {
+    const response = await fetch('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': credentials.apiKey || credentials.sessionKey,
+        'anthropic-version': '2023-06-01'
+      },
+      body: JSON.stringify({
+        model: 'claude-sonnet-4-5-20250929',
+        max_tokens: 10,
+        messages: [{ role: 'user', content: 'Hi' }]
+      })
+    });
+    
+    if (response.ok) {
+      return { valid: true };
+    }
+    
+    const error = await response.json();
+    return { valid: false, error: error.error?.message || 'Invalid API key' };
+  } catch (e) {
+    return { valid: false, error: e.message };
+  }
+};
+
+const validateOpenAI = async (credentials) => {
+  try {
+    const response = await fetch('https://api.openai.com/v1/models', {
+      headers: {
+        'Authorization': `Bearer ${credentials.apiKey || credentials.accessToken}`
+      }
+    });
+    
+    if (response.ok) {
+      return { valid: true };
+    }
+    
+    return { valid: false, error: 'Invalid API key' };
+  } catch (e) {
+    return { valid: false, error: e.message };
+  }
+};
+
+const validateGemini = async (credentials) => {
+  try {
+    const response = await fetch(
+      `https://generativelanguage.googleapis.com/v1/models?key=${credentials.apiKey}`
+    );
+    
+    if (response.ok) {
+      return { valid: true };
+    }
+    
+    return { valid: false, error: 'Invalid API key' };
+  } catch (e) {
+    return { valid: false, error: e.message };
+  }
+};
+
+const validateDeepSeek = async (credentials) => {
+  try {
+    const response = await fetch('https://api.deepseek.com/v1/models', {
+      headers: {
+        'Authorization': `Bearer ${credentials.apiKey}`
+      }
+    });
+    
+    if (response.ok) {
+      return { valid: true };
+    }
+    
+    return { valid: false, error: 'Invalid API key' };
+  } catch (e) {
+    return { valid: false, error: e.message };
+  }
+};
+
+const validateGroq = async (credentials) => {
+  try {
+    const response = await fetch('https://api.groq.com/openai/v1/models', {
+      headers: {
+        'Authorization': `Bearer ${credentials.apiKey}`
+      }
+    });
+    
+    if (response.ok) {
+      return { valid: true };
+    }
+    
+    return { valid: false, error: 'Invalid API key' };
+  } catch (e) {
+    return { valid: false, error: e.message };
+  }
+};
+
+const validateOllama = async (credentials) => {
+  try {
+    const endpoint = credentials.endpoint || 'http://localhost:11434';
+    const response = await fetch(`${endpoint}/api/tags`);
+    
+    if (response.ok) {
+      const data = await response.json();
+      return { 
+        valid: true, 
+        models: data.models?.map(m => m.name) || [] 
+      };
+    }
+    
+    return { valid: false, error: 'Cannot connect to Ollama' };
+  } catch (e) {
+    return { valid: false, error: 'Ollama not running. Start with: ollama serve' };
+  }
+};
+
+const validateCustom = async (credentials) => {
+  try {
+    const response = await fetch(`${credentials.endpoint}/models`, {
+      headers: credentials.apiKey ? {
+        'Authorization': `Bearer ${credentials.apiKey}`
+      } : {}
+    });
+    
+    if (response.ok) {
+      return { valid: true };
+    }
+    
+    return { valid: false, error: 'Cannot connect to endpoint' };
+  } catch (e) {
+    return { valid: false, error: e.message };
+  }
+};
+
+const validateOpenRouter = async (credentials) => {
+  try {
+    const response = await fetch('https://openrouter.ai/api/v1/models', {
+      headers: {
+        'Authorization': `Bearer ${credentials.apiKey}`
+      }
+    });
+    
+    if (response.ok) {
+      return { valid: true };
+    }
+    
+    return { valid: false, error: 'Invalid API key' };
+  } catch (e) {
+    return { valid: false, error: e.message };
+  }
+};
+
+const validateLMStudio = async (credentials) => {
+  try {
+    const endpoint = credentials.endpoint || 'http://localhost:1234/v1';
+    const response = await fetch(`${endpoint}/models`);
+    
+    if (response.ok) {
+      const data = await response.json();
+      return { 
+        valid: true, 
+        models: data.data?.map(m => m.id) || [] 
+      };
+    }
+    
+    return { valid: false, error: 'Cannot connect to LM Studio' };
+  } catch (e) {
+    return { valid: false, error: 'LM Studio not running. Start local server first.' };
+  }
+};
+
+const validateOpenAICompatible = async (provider, credentials) => {
+  try {
+    const endpoint = provider.endpoint;
+    const response = await fetch(`${endpoint}/models`, {
+      headers: {
+        'Authorization': `Bearer ${credentials.apiKey}`,
+        'Content-Type': 'application/json'
+      }
+    });
+    
+    if (response.ok) {
+      return { valid: true };
+    }
+    
+    // Some providers don't have /models endpoint, try a simple chat
+    const chatResponse = await fetch(`${endpoint}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${credentials.apiKey}`,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        model: provider.defaultModel,
+        messages: [{ role: 'user', content: 'hi' }],
+        max_tokens: 5
+      })
+    });
+    
+    if (chatResponse.ok) {
+      return { valid: true };
+    }
+    
+    return { valid: false, error: 'Invalid API key or endpoint' };
+  } catch (e) {
+    return { valid: false, error: e.message };
+  }
+};
+
+module.exports = {
+  getProviders,
+  getProvider,
+  isConnected,
+  getConnection,
+  connect,
+  disconnect,
+  getCredentials,
+  validateConnection,
+  getAISettings,
+  saveAISettings
+};

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

@@ -0,0 +1,490 @@
+/**
+ * AI Providers Configuration
+ * Each provider has connection options (API Key, Plans, etc.)
+ */
+
+const PROVIDERS = {
+  // ========== UNIFIED PROVIDERS (RECOMMENDED) ==========
+  openrouter: {
+    id: 'openrouter',
+    name: 'OPENROUTER (RECOMMENDED)',
+    description: '1 API key for 100+ models',
+    category: 'unified',
+    models: [
+      'anthropic/claude-sonnet-4',
+      'anthropic/claude-3-opus',
+      'openai/gpt-4o',
+      'openai/gpt-4-turbo',
+      'google/gemini-pro-1.5',
+      'meta-llama/llama-3-70b',
+      'mistralai/mistral-large',
+      'deepseek/deepseek-chat'
+    ],
+    defaultModel: 'anthropic/claude-sonnet-4',
+    options: [
+      {
+        id: 'api_key',
+        label: 'API KEY',
+        description: [
+          'Get key at openrouter.ai/keys',
+          'Access to Claude, GPT-4, Gemini, Llama & more',
+          'Pay-per-use, no subscriptions'
+        ],
+        fields: ['apiKey'],
+        url: 'https://openrouter.ai/keys'
+      }
+    ],
+    endpoint: 'https://openrouter.ai/api/v1'
+  },
+
+  // ========== DIRECT PROVIDERS ==========
+  anthropic: {
+    id: 'anthropic',
+    name: 'CLAUDE (ANTHROPIC)',
+    description: 'Direct connection to Claude',
+    category: 'direct',
+    models: ['claude-sonnet-4-5-20250929', 'claude-3-opus-20240229', 'claude-3-haiku-20240307'],
+    defaultModel: 'claude-sonnet-4-5-20250929',
+    options: [
+      {
+        id: 'api_key',
+        label: 'API KEY (PAY-PER-USE)',
+        description: [
+          'Get key at console.anthropic.com',
+          '~$0.10 per trading session'
+        ],
+        fields: ['apiKey'],
+        url: 'https://console.anthropic.com'
+      },
+      {
+        id: 'max_plan',
+        label: 'MAX PLAN ($100/MONTH)',
+        description: [
+          'Subscribe at claude.ai',
+          'Unlimited usage'
+        ],
+        fields: ['sessionKey'],
+        url: 'https://claude.ai'
+      }
+    ],
+    endpoint: 'https://api.anthropic.com/v1'
+  },
+  
+  openai: {
+    id: 'openai',
+    name: 'OPENAI (GPT-4)',
+    description: 'Direct connection to GPT-4',
+    category: 'direct',
+    models: ['gpt-4o', 'gpt-4-turbo', 'gpt-4o-mini', 'gpt-3.5-turbo'],
+    defaultModel: 'gpt-4o',
+    options: [
+      {
+        id: 'api_key',
+        label: 'API KEY (PAY-PER-USE)',
+        description: [
+          'Get key at platform.openai.com',
+          '~$0.15 per trading session'
+        ],
+        fields: ['apiKey'],
+        url: 'https://platform.openai.com/api-keys'
+      },
+      {
+        id: 'plus_plan',
+        label: 'PLUS PLAN ($20/MONTH)',
+        description: [
+          'Subscribe at chat.openai.com',
+          'GPT-4 access included'
+        ],
+        fields: ['accessToken'],
+        url: 'https://chat.openai.com'
+      }
+    ],
+    endpoint: 'https://api.openai.com/v1'
+  },
+  
+  gemini: {
+    id: 'gemini',
+    name: 'GEMINI (GOOGLE)',
+    description: 'Direct connection to Gemini',
+    category: 'direct',
+    models: ['gemini-1.5-pro', 'gemini-1.5-flash', 'gemini-pro'],
+    defaultModel: 'gemini-1.5-flash',
+    options: [
+      {
+        id: 'api_key',
+        label: 'API KEY (FREE TIER)',
+        description: [
+          'Get key at aistudio.google.com',
+          'Free tier: 60 requests/min'
+        ],
+        fields: ['apiKey'],
+        url: 'https://aistudio.google.com/apikey'
+      }
+    ],
+    endpoint: 'https://generativelanguage.googleapis.com/v1'
+  },
+  
+  deepseek: {
+    id: 'deepseek',
+    name: 'DEEPSEEK',
+    description: 'Very cheap & capable',
+    category: 'direct',
+    models: ['deepseek-chat', 'deepseek-coder'],
+    defaultModel: 'deepseek-chat',
+    options: [
+      {
+        id: 'api_key',
+        label: 'API KEY (VERY CHEAP)',
+        description: [
+          'Get key at platform.deepseek.com',
+          '~$0.02 per trading session'
+        ],
+        fields: ['apiKey'],
+        url: 'https://platform.deepseek.com'
+      }
+    ],
+    endpoint: 'https://api.deepseek.com/v1'
+  },
+  
+  groq: {
+    id: 'groq',
+    name: 'GROQ',
+    description: 'Ultra fast inference',
+    category: 'direct',
+    models: ['llama-3.3-70b-versatile', 'llama-3.1-8b-instant', 'mixtral-8x7b-32768'],
+    defaultModel: 'llama-3.3-70b-versatile',
+    options: [
+      {
+        id: 'api_key',
+        label: 'API KEY (FREE TIER)',
+        description: [
+          'Get key at console.groq.com',
+          'Generous free tier',
+          'Ultra low latency'
+        ],
+        fields: ['apiKey'],
+        url: 'https://console.groq.com/keys'
+      }
+    ],
+    endpoint: 'https://api.groq.com/openai/v1'
+  },
+
+  xai: {
+    id: 'xai',
+    name: 'GROK (XAI)',
+    description: 'Elon Musk\'s Grok AI',
+    category: 'direct',
+    models: ['grok-beta', 'grok-2'],
+    defaultModel: 'grok-beta',
+    options: [
+      {
+        id: 'api_key',
+        label: 'API KEY',
+        description: [
+          'Get key at console.x.ai',
+          'Grok models from xAI'
+        ],
+        fields: ['apiKey'],
+        url: 'https://console.x.ai'
+      }
+    ],
+    endpoint: 'https://api.x.ai/v1'
+  },
+
+  mistral: {
+    id: 'mistral',
+    name: 'MISTRAL',
+    description: 'European AI leader',
+    category: 'direct',
+    models: ['mistral-large-latest', 'mistral-medium', 'mistral-small'],
+    defaultModel: 'mistral-large-latest',
+    options: [
+      {
+        id: 'api_key',
+        label: 'API KEY',
+        description: [
+          'Get key at console.mistral.ai',
+          'Fast European models'
+        ],
+        fields: ['apiKey'],
+        url: 'https://console.mistral.ai'
+      }
+    ],
+    endpoint: 'https://api.mistral.ai/v1'
+  },
+
+  perplexity: {
+    id: 'perplexity',
+    name: 'PERPLEXITY',
+    description: 'Real-time web search AI',
+    category: 'direct',
+    models: ['llama-3.1-sonar-large-128k-online', 'llama-3.1-sonar-small-128k-online', 'llama-3.1-sonar-huge-128k-online'],
+    defaultModel: 'llama-3.1-sonar-large-128k-online',
+    options: [
+      {
+        id: 'api_key',
+        label: 'API KEY',
+        description: [
+          'Get key at perplexity.ai/settings/api',
+          'Real-time market news & data',
+          'Web search integrated'
+        ],
+        fields: ['apiKey'],
+        url: 'https://www.perplexity.ai/settings/api'
+      }
+    ],
+    endpoint: 'https://api.perplexity.ai'
+  },
+
+  together: {
+    id: 'together',
+    name: 'TOGETHER AI',
+    description: 'Open source models, fast & cheap',
+    category: 'direct',
+    models: ['meta-llama/Llama-3.3-70B-Instruct-Turbo', 'mistralai/Mixtral-8x22B-Instruct-v0.1', 'Qwen/Qwen2.5-72B-Instruct-Turbo'],
+    defaultModel: 'meta-llama/Llama-3.3-70B-Instruct-Turbo',
+    options: [
+      {
+        id: 'api_key',
+        label: 'API KEY',
+        description: [
+          'Get key at api.together.xyz',
+          '100+ open source models',
+          'Fast inference, good pricing'
+        ],
+        fields: ['apiKey'],
+        url: 'https://api.together.xyz/settings/api-keys'
+      }
+    ],
+    endpoint: 'https://api.together.xyz/v1'
+  },
+
+
+  qwen: {
+    id: 'qwen',
+    name: 'QWEN (ALIBABA)',
+    description: 'Alibaba\'s top AI model',
+    category: 'direct',
+    models: ['qwen-turbo', 'qwen-plus', 'qwen-max'],
+    defaultModel: 'qwen-plus',
+    options: [
+      {
+        id: 'api_key',
+        label: 'API KEY (DASHSCOPE)',
+        description: [
+          'Get key at dashscope.aliyun.com',
+          'Qwen2.5 models',
+          'Very competitive pricing'
+        ],
+        fields: ['apiKey'],
+        url: 'https://dashscope.console.aliyun.com/apiKey'
+      }
+    ],
+    endpoint: 'https://dashscope.aliyuncs.com/compatible-mode/v1'
+  },
+
+  moonshot: {
+    id: 'moonshot',
+    name: 'MOONSHOT (KIMI)',
+    description: '200K context window',
+    category: 'direct',
+    models: ['moonshot-v1-8k', 'moonshot-v1-32k', 'moonshot-v1-128k'],
+    defaultModel: 'moonshot-v1-32k',
+    options: [
+      {
+        id: 'api_key',
+        label: 'API KEY',
+        description: [
+          'Get key at platform.moonshot.cn',
+          'Up to 200K context',
+          'Good for long documents'
+        ],
+        fields: ['apiKey'],
+        url: 'https://platform.moonshot.cn/console/api-keys'
+      }
+    ],
+    endpoint: 'https://api.moonshot.cn/v1'
+  },
+
+  yi: {
+    id: 'yi',
+    name: '01.AI (YI)',
+    description: 'Yi models by Kai-Fu Lee',
+    category: 'direct',
+    models: ['yi-large', 'yi-medium', 'yi-spark'],
+    defaultModel: 'yi-large',
+    options: [
+      {
+        id: 'api_key',
+        label: 'API KEY',
+        description: [
+          'Get key at platform.01.ai',
+          'Yi-Large: GPT-4 level',
+          'Affordable pricing'
+        ],
+        fields: ['apiKey'],
+        url: 'https://platform.01.ai'
+      }
+    ],
+    endpoint: 'https://api.01.ai/v1'
+  },
+
+  zhipu: {
+    id: 'zhipu',
+    name: 'ZHIPU AI (GLM)',
+    description: 'ChatGLM models',
+    category: 'direct',
+    models: ['glm-4-plus', 'glm-4', 'glm-4-flash'],
+    defaultModel: 'glm-4',
+    options: [
+      {
+        id: 'api_key',
+        label: 'API KEY',
+        description: [
+          'Get key at open.bigmodel.cn',
+          'ChatGLM-4 models',
+          'Strong multilingual'
+        ],
+        fields: ['apiKey'],
+        url: 'https://open.bigmodel.cn/usercenter/apikeys'
+      }
+    ],
+    endpoint: 'https://open.bigmodel.cn/api/paas/v4'
+  },
+
+  baichuan: {
+    id: 'baichuan',
+    name: 'BAICHUAN',
+    description: 'Chinese language specialist',
+    category: 'direct',
+    models: ['Baichuan4', 'Baichuan3-Turbo', 'Baichuan2-Turbo'],
+    defaultModel: 'Baichuan4',
+    options: [
+      {
+        id: 'api_key',
+        label: 'API KEY',
+        description: [
+          'Get key at platform.baichuan-ai.com',
+          'Best for Chinese content',
+          'Competitive pricing'
+        ],
+        fields: ['apiKey'],
+        url: 'https://platform.baichuan-ai.com/console/apikey'
+      }
+    ],
+    endpoint: 'https://api.baichuan-ai.com/v1'
+  },
+
+  // ========== LOCAL / FREE ==========
+  ollama: {
+    id: 'ollama',
+    name: 'OLLAMA (LOCAL - FREE)',
+    description: '100% free, runs locally',
+    category: 'local',
+    models: ['llama3', 'llama3.1', 'mistral', 'codellama', 'phi3', 'gemma2'],
+    defaultModel: 'llama3.1',
+    options: [
+      {
+        id: 'local',
+        label: 'LOCAL INSTALLATION (FREE)',
+        description: [
+          'Download at ollama.ai',
+          '100% free, no API key needed',
+          'Run: ollama pull llama3.1'
+        ],
+        fields: ['endpoint'],
+        url: 'https://ollama.ai',
+        defaultEndpoint: 'http://localhost:11434'
+      }
+    ]
+  },
+
+  lmstudio: {
+    id: 'lmstudio',
+    name: 'LM STUDIO (LOCAL - FREE)',
+    description: 'Local with GUI',
+    category: 'local',
+    models: [],
+    defaultModel: '',
+    options: [
+      {
+        id: 'local',
+        label: 'LOCAL SERVER (FREE)',
+        description: [
+          'Download at lmstudio.ai',
+          'GUI for local models',
+          'OpenAI-compatible API'
+        ],
+        fields: ['endpoint'],
+        url: 'https://lmstudio.ai',
+        defaultEndpoint: 'http://localhost:1234/v1'
+      }
+    ]
+  },
+  
+  // ========== CUSTOM ==========
+  custom: {
+    id: 'custom',
+    name: 'CUSTOM ENDPOINT',
+    description: 'Any OpenAI-compatible API',
+    category: 'custom',
+    models: [],
+    defaultModel: '',
+    options: [
+      {
+        id: 'custom',
+        label: 'CUSTOM OPENAI-COMPATIBLE API',
+        description: [
+          'Self-hosted models',
+          'vLLM, TGI, etc.',
+          'Any OpenAI-compatible endpoint'
+        ],
+        fields: ['endpoint', 'apiKey', 'model']
+      }
+    ]
+  }
+};
+
+/**
+ * Get all providers
+ */
+const getProviders = () => Object.values(PROVIDERS);
+
+/**
+ * Get providers by category
+ */
+const getProvidersByCategory = (category) => {
+  return Object.values(PROVIDERS).filter(p => p.category === category);
+};
+
+/**
+ * Get provider by ID
+ */
+const getProvider = (id) => PROVIDERS[id] || null;
+
+/**
+ * Get provider options
+ */
+const getProviderOptions = (id) => {
+  const provider = PROVIDERS[id];
+  return provider ? provider.options : [];
+};
+
+/**
+ * Get categories
+ */
+const getCategories = () => [
+  { id: 'unified', name: 'UNIFIED (RECOMMENDED)', description: '1 API key for multiple models' },
+  { id: 'direct', name: 'DIRECT PROVIDERS', description: 'Connect directly to each provider' },
+  { id: 'local', name: 'LOCAL (FREE)', description: 'Run models on your machine' },
+  { id: 'custom', name: 'CUSTOM', description: 'Self-hosted solutions' }
+];
+
+module.exports = {
+  PROVIDERS,
+  getProviders,
+  getProvidersByCategory,
+  getProvider,
+  getProviderOptions,
+  getCategories
+};