hedgequantx 2.8.3 → 2.9.0

package/package.json

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

package/src/pages/ai-agents-ui.js

@@ -239,7 +239,8 @@ const drawModelsTable = (provider, models, boxWidth) => {
 
 /**
  * Draw provider configuration window
- * @param {Object} provider - Provider object
+ * Shows connection options based on provider capabilities (OAuth and/or API Key)
+ * @param {Object} provider - Provider object with supportsOAuth and supportsApiKey flags
  * @param {Object} config - Current config
  * @param {number} boxWidth - Box width
  */
@@ -249,32 +250,47 @@ const drawProviderWindow = (provider, config, boxWidth) => {
   const col2Width = W - col1Width;
   const providerConfig = config.providers[provider.id] || {};
   
+  // Check provider capabilities (default to both if not specified)
+  const supportsOAuth = provider.supportsOAuth !== false;
+  const supportsApiKey = provider.supportsApiKey !== false;
+  
   // New rectangle (banner is always closed)
   console.log(chalk.cyan('╔' + '═'.repeat(W) + '╗'));
   console.log(chalk.cyan('║') + chalk[provider.color].bold(centerText(provider.name.toUpperCase(), W)) + chalk.cyan('║'));
   console.log(chalk.cyan('╠' + '═'.repeat(W) + '╣'));
   
-  // Options in 2 columns (centered)
-  const opt1 = '[1] CONNECT VIA PAID PLAN';
-  const opt2 = '[2] CONNECT VIA API KEY';
-  
-  const left1 = chalk.green(opt1);
-  const right1 = chalk.yellow(opt2);
-  const left1Len = visibleLength(left1);
-  const right1Len = visibleLength(right1);
-  const left1PadTotal = col1Width - left1Len;
-  const left1PadL = Math.floor(left1PadTotal / 2);
-  const left1PadR = left1PadTotal - left1PadL;
-  const right1PadTotal = col2Width - right1Len;
-  const right1PadL = Math.floor(right1PadTotal / 2);
-  const right1PadR = right1PadTotal - right1PadL;
-  
-  console.log(
-    chalk.cyan('║') +
-    ' '.repeat(left1PadL) + left1 + ' '.repeat(left1PadR) +
-    ' '.repeat(right1PadL) + right1 + ' '.repeat(right1PadR) +
-    chalk.cyan('║')
-  );
+  // Display connection options based on provider capabilities
+  if (supportsOAuth && supportsApiKey) {
+    // Both options: 2 columns
+    const opt1 = '[1] CONNECT VIA PAID PLAN';
+    const opt2 = '[2] CONNECT VIA API KEY';
+    
+    const left1 = chalk.green(opt1);
+    const right1 = chalk.yellow(opt2);
+    const left1Len = visibleLength(left1);
+    const right1Len = visibleLength(right1);
+    const left1PadTotal = col1Width - left1Len;
+    const left1PadL = Math.floor(left1PadTotal / 2);
+    const left1PadR = left1PadTotal - left1PadL;
+    const right1PadTotal = col2Width - right1Len;
+    const right1PadL = Math.floor(right1PadTotal / 2);
+    const right1PadR = right1PadTotal - right1PadL;
+    
+    console.log(
+      chalk.cyan('║') +
+      ' '.repeat(left1PadL) + left1 + ' '.repeat(left1PadR) +
+      ' '.repeat(right1PadL) + right1 + ' '.repeat(right1PadR) +
+      chalk.cyan('║')
+    );
+  } else if (supportsApiKey) {
+    // API Key only: centered single option
+    const opt = '[1] CONNECT VIA API KEY';
+    console.log(chalk.cyan('║') + chalk.yellow(centerText(opt, W)) + chalk.cyan('║'));
+  } else if (supportsOAuth) {
+    // OAuth only: centered single option
+    const opt = '[1] CONNECT VIA PAID PLAN';
+    console.log(chalk.cyan('║') + chalk.green(centerText(opt, W)) + chalk.cyan('║'));
+  }
   
   // Status bar
   console.log(chalk.cyan('╠' + '─'.repeat(W) + '╣'));

package/src/pages/ai-agents.js

@@ -1,9 +1,4 @@
-/**
- * AI Agents Configuration Page
- * 
- * Allows users to configure AI providers for trading strategies.
- * Supports both CLIProxy (paid plans) and direct API keys.
- */
+/** AI Agents Configuration Page - CLIProxy (OAuth) + LLM Proxy (API Key) */
 
 const chalk = require('chalk');
 const os = require('os');
@@ -27,16 +22,24 @@ const clearWithBanner = () => {
 const CONFIG_DIR = path.join(os.homedir(), '.hqx');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'ai-config.json');
 
-// AI Providers list
+// AI Providers list with OAuth (paid plan) and API Key support
+// CLIProxyAPI (port 8317): OAuth for Anthropic, OpenAI, Google, Qwen, iFlow
+// LLM Proxy (port 8318): API Key for all providers via LiteLLM
 const AI_PROVIDERS = [
-  { id: 'anthropic', name: 'Anthropic (Claude)', color: 'magenta' },
-  { id: 'openai', name: 'OpenAI (GPT)', color: 'green' },
-  { id: 'google', name: 'Google (Gemini)', color: 'blue' },
-  { id: 'mistral', name: 'Mistral AI', color: 'yellow' },
-  { id: 'groq', name: 'Groq', color: 'cyan' },
-  { id: 'xai', name: 'xAI (Grok)', color: 'white' },
-  { id: 'perplexity', name: 'Perplexity', color: 'blue' },
-  { id: 'openrouter', name: 'OpenRouter', color: 'gray' },
+  // OAuth + API Key supported (can use paid plan OR API key)
+  { id: 'anthropic', name: 'Anthropic (Claude)', color: 'magenta', supportsOAuth: true, supportsApiKey: true },
+  { id: 'openai', name: 'OpenAI (GPT)', color: 'green', supportsOAuth: true, supportsApiKey: true },
+  { id: 'google', name: 'Google (Gemini)', color: 'blue', supportsOAuth: true, supportsApiKey: true },
+  { id: 'qwen', name: 'Qwen', color: 'cyan', supportsOAuth: true, supportsApiKey: true },
+  { id: 'iflow', name: 'iFlow (DeepSeek/GLM)', color: 'yellow', supportsOAuth: true, supportsApiKey: true },
+  // API Key only (no OAuth - uses LLM Proxy via LiteLLM)
+  { id: 'deepseek', name: 'DeepSeek', color: 'blue', supportsOAuth: false, supportsApiKey: true },
+  { id: 'minimax', name: 'MiniMax', color: 'magenta', supportsOAuth: false, supportsApiKey: true },
+  { id: 'mistral', name: 'Mistral AI', color: 'yellow', supportsOAuth: false, supportsApiKey: true },
+  { id: 'groq', name: 'Groq', color: 'cyan', supportsOAuth: false, supportsApiKey: true },
+  { id: 'xai', name: 'xAI (Grok)', color: 'white', supportsOAuth: false, supportsApiKey: true },
+  { id: 'perplexity', name: 'Perplexity', color: 'blue', supportsOAuth: false, supportsApiKey: true },
+  { id: 'openrouter', name: 'OpenRouter', color: 'gray', supportsOAuth: false, supportsApiKey: true },
 ];
 
 /** Load AI config from file */
@@ -342,6 +345,10 @@ const handleApiKeyConnection = async (provider, config) => {
 const handleProviderConfig = async (provider, config) => {
   const boxWidth = getLogoWidth();
   
+  // Check provider capabilities
+  const supportsOAuth = provider.supportsOAuth !== false;
+  const supportsApiKey = provider.supportsApiKey !== false;
+  
   while (true) {
     clearWithBanner();
     drawProviderWindow(provider, config, boxWidth);
@@ -360,11 +367,21 @@ const handleProviderConfig = async (provider, config) => {
     }
     
     if (choice === '1') {
-      await handleCliProxyConnection(provider, config, boxWidth);
+      if (supportsOAuth && supportsApiKey) {
+        // Both supported: [1] = OAuth via CLIProxy
+        await handleCliProxyConnection(provider, config, boxWidth);
+      } else if (supportsApiKey) {
+        // API Key only: [1] = API Key via LLM Proxy
+        await handleApiKeyConnection(provider, config);
+      } else if (supportsOAuth) {
+        // OAuth only: [1] = OAuth via CLIProxy
+        await handleCliProxyConnection(provider, config, boxWidth);
+      }
       continue;
     }
     
-    if (choice === '2') {
+    if (choice === '2' && supportsOAuth && supportsApiKey) {
+      // Only available when both are supported: [2] = API Key
       await handleApiKeyConnection(provider, config);
       continue;
     }

package/src/pages/ai-models.js

@@ -9,11 +9,14 @@ const https = require('https');
 
 /**
  * API endpoints for fetching models
+ * Using beta endpoints where available for latest 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',
+  google: 'https://generativelanguage.googleapis.com/v1beta/models', // v1beta for Gemini 3
+  deepseek: 'https://api.deepseek.com/v1/models',
+  minimax: 'https://api.minimax.chat/v1/models',
   mistral: 'https://api.mistral.ai/v1/models',
   groq: 'https://api.groq.com/openai/v1/models',
   xai: 'https://api.x.ai/v1/models',
@@ -84,80 +87,239 @@ const getAuthHeaders = (providerId, apiKey) => {
     case 'anthropic':
       return { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' };
     case 'openai':
+    case 'deepseek':
+    case 'minimax':
     case 'groq':
     case 'xai':
     case 'perplexity':
     case 'openrouter':
+    case 'mistral':
       return { 'Authorization': `Bearer ${apiKey}` };
     case 'google':
       return {}; // Google uses query param
-    case 'mistral':
-      return { 'Authorization': `Bearer ${apiKey}` };
     default:
       return { 'Authorization': `Bearer ${apiKey}` };
   }
 };
 
 /**
- * Parse models response based on provider
+ * Excluded patterns - models NOT suitable for algo trading
+ * These are image, audio, embedding, moderation models
+ */
+const EXCLUDED_PATTERNS = [
+  'whisper', 'tts', 'dall-e', 'embedding', 'embed', 'moderation',
+  'image', 'vision', 'audio', 'speech', 'realtime', 'transcription',
+  'aqa', 'gecko', 'bison', 'learnlm'
+];
+
+/**
+ * Check if model should be excluded (not for algo trading)
+ * @param {string} modelId - Model ID
+ * @returns {boolean} True if should be excluded
+ */
+const shouldExcludeModel = (modelId) => {
+  const id = modelId.toLowerCase();
+  return EXCLUDED_PATTERNS.some(pattern => id.includes(pattern));
+};
+
+/**
+ * Extract version number from model ID for sorting
+ * @param {string} modelId - Model ID
+ * @returns {number} Version number (higher = newer)
+ */
+const extractVersion = (modelId) => {
+  const id = modelId.toLowerCase();
+  
+  // Gemini: gemini-3 > gemini-2.5 > gemini-2.0
+  const geminiMatch = id.match(/gemini-(\d+\.?\d*)/);
+  if (geminiMatch) return parseFloat(geminiMatch[1]) * 100;
+  
+  // Claude: opus-4.5 > opus-4 > sonnet-4 > haiku
+  if (id.includes('opus-4.5') || id.includes('opus-4-5')) return 450;
+  if (id.includes('opus-4.1') || id.includes('opus-4-1')) return 410;
+  if (id.includes('opus-4')) return 400;
+  if (id.includes('sonnet-4.5') || id.includes('sonnet-4-5')) return 350;
+  if (id.includes('sonnet-4')) return 340;
+  if (id.includes('haiku-4.5') || id.includes('haiku-4-5')) return 250;
+  if (id.includes('sonnet-3.7') || id.includes('3-7-sonnet')) return 237;
+  if (id.includes('sonnet-3.5') || id.includes('3-5-sonnet')) return 235;
+  if (id.includes('haiku-3.5') || id.includes('3-5-haiku')) return 135;
+  if (id.includes('opus')) return 300;
+  if (id.includes('sonnet')) return 200;
+  if (id.includes('haiku')) return 100;
+  
+  // GPT: gpt-4o > gpt-4-turbo > gpt-4 > gpt-3.5
+  if (id.includes('gpt-4o')) return 450;
+  if (id.includes('gpt-4-turbo')) return 420;
+  if (id.includes('gpt-4')) return 400;
+  if (id.includes('gpt-3.5')) return 350;
+  if (id.includes('o1')) return 500; // o1 reasoning models
+  if (id.includes('o3')) return 530; // o3 reasoning models
+  
+  // Mistral: large > medium > small
+  if (id.includes('large')) return 300;
+  if (id.includes('medium')) return 200;
+  if (id.includes('small') || id.includes('tiny')) return 100;
+  
+  // Default
+  return 50;
+};
+
+/**
+ * Get model tier for display (Pro/Flash/Lite)
+ * @param {string} modelId - Model ID
+ * @returns {number} Tier weight (higher = more powerful)
+ */
+const getModelTier = (modelId) => {
+  const id = modelId.toLowerCase();
+  if (id.includes('pro') || id.includes('opus') || id.includes('large')) return 30;
+  if (id.includes('flash') || id.includes('sonnet') || id.includes('medium')) return 20;
+  if (id.includes('lite') || id.includes('haiku') || id.includes('small')) return 10;
+  return 15;
+};
+
+/**
+ * Parse models response based on provider - filtered for algo trading
  * @param {string} providerId - Provider ID
  * @param {Object} data - API response data
- * @returns {Array} Parsed models list
+ * @returns {Array} Parsed and filtered models list
  */
 const parseModelsResponse = (providerId, data) => {
   if (!data) return [];
   
   try {
+    let models = [];
+    
     switch (providerId) {
       case 'anthropic':
         // Anthropic returns { data: [{ id, display_name, ... }] }
-        return (data.data || []).map(m => ({
-          id: m.id,
-          name: m.display_name || m.id
-        }));
+        models = (data.data || [])
+          .filter(m => m.id && !shouldExcludeModel(m.id))
+          .map(m => ({
+            id: m.id,
+            name: m.display_name || m.id
+          }));
+        break;
       
       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'))
+        models = (data.data || [])
+          .filter(m => m.id && !shouldExcludeModel(m.id))
+          .filter(m => m.id.startsWith('gpt-') || m.id.startsWith('o1') || m.id.startsWith('o3'))
           .map(m => ({
             id: m.id,
             name: m.id
           }));
+        break;
       
       case 'google':
-        // Google format: { models: [{ name, displayName, ... }] }
-        return (data.models || []).map(m => ({
-          id: m.name?.replace('models/', '') || m.name,
-          name: m.displayName || m.name
-        }));
+        // Google format: { models: [{ name, displayName, supportedGenerationMethods }] }
+        models = (data.models || [])
+          .filter(m => {
+            const id = m.name?.replace('models/', '') || '';
+            // Only Gemini chat models
+            return id.startsWith('gemini-') && 
+                   !shouldExcludeModel(id) &&
+                   m.supportedGenerationMethods?.includes('generateContent');
+          })
+          .map(m => ({
+            id: m.name?.replace('models/', '') || m.name,
+            name: m.displayName || m.name
+          }));
+        break;
+      
+      case 'groq':
+        // Groq format: { data: [{ id, ... }] }
+        models = (data.data || [])
+          .filter(m => m.id && !shouldExcludeModel(m.id))
+          .map(m => ({
+            id: m.id,
+            name: m.id
+          }));
+        break;
+      
+      case 'deepseek':
+        // DeepSeek format: { data: [{ id, ... }] } - OpenAI compatible
+        models = (data.data || [])
+          .filter(m => m.id && !shouldExcludeModel(m.id))
+          .filter(m => m.id.includes('deepseek'))
+          .map(m => ({
+            id: m.id,
+            name: m.id
+          }));
+        break;
+      
+      case 'minimax':
+        // MiniMax format: { data: [{ id, ... }] } or { models: [...] }
+        models = (data.data || data.models || [])
+          .filter(m => (m.id || m.model) && !shouldExcludeModel(m.id || m.model))
+          .map(m => ({
+            id: m.id || m.model,
+            name: m.id || m.model
+          }));
+        break;
+      
+      case 'xai':
+        // xAI format: { data: [{ id, ... }] }
+        models = (data.data || [])
+          .filter(m => m.id && !shouldExcludeModel(m.id))
+          .filter(m => m.id.includes('grok'))
+          .map(m => ({
+            id: m.id,
+            name: m.id
+          }));
+        break;
       
       case 'mistral':
         // Mistral format: { data: [{ id, ... }] }
-        return (data.data || []).map(m => ({
-          id: m.id,
-          name: m.id
-        }));
+        models = (data.data || [])
+          .filter(m => m.id && !shouldExcludeModel(m.id))
+          .map(m => ({
+            id: m.id,
+            name: m.id
+          }));
+        break;
       
       case 'perplexity':
         // Perplexity format varies
-        return (data.models || data.data || []).map(m => ({
-          id: m.id || m.model,
-          name: m.id || m.model
-        }));
+        models = (data.models || data.data || [])
+          .filter(m => (m.id || m.model) && !shouldExcludeModel(m.id || m.model))
+          .map(m => ({
+            id: m.id || m.model,
+            name: m.id || m.model
+          }));
+        break;
       
       case 'openrouter':
         // OpenRouter format: { data: [{ id, name, ... }] }
-        return (data.data || []).map(m => ({
-          id: m.id,
-          name: m.name || m.id
-        }));
+        // Filter to show only main providers' chat models
+        models = (data.data || [])
+          .filter(m => {
+            if (!m.id || shouldExcludeModel(m.id)) return false;
+            // Only keep major providers for trading
+            const validPrefixes = [
+              'anthropic/claude', 'openai/gpt', 'openai/o1', 'openai/o3',
+              'google/gemini', 'mistralai/', 'meta-llama/', 'x-ai/grok'
+            ];
+            return validPrefixes.some(p => m.id.startsWith(p));
+          })
+          .map(m => ({
+            id: m.id,
+            name: m.name || m.id
+          }));
+        break;
       
       default:
         return [];
     }
+    
+    // Sort by version (newest first), then by tier (most powerful first)
+    return models.sort((a, b) => {
+      const versionDiff = extractVersion(b.id) - extractVersion(a.id);
+      if (versionDiff !== 0) return versionDiff;
+      return getModelTier(b.id) - getModelTier(a.id);
+    });
+    
   } catch (error) {
     return [];
   }

package/src/services/index.js

@@ -2,13 +2,14 @@
  * @fileoverview Services module exports
  * @module services
  * 
- * Rithmic-only service hub + AI Supervision
+ * Rithmic-only service hub + AI Supervision + Dual Proxy Support
  */
 
 const { RithmicService } = require('./rithmic/index');
 const { HQXServerService } = require('./hqx-server/index');
 const { storage, connections } = require('./session');
 const aiSupervision = require('./ai-supervision');
+const llmproxy = require('./llmproxy');
 
 module.exports = {
   // Platform Service (Rithmic only)
@@ -23,4 +24,7 @@ module.exports = {
   
   // AI Supervision
   aiSupervision,
+  
+  // LLM API Proxy (for API key providers via LiteLLM)
+  llmproxy,
 };

package/src/services/llmproxy/index.js

@@ -0,0 +1,166 @@
+/**
+ * LLM API Proxy Service
+ * 
+ * Uses LiteLLM (Python) to provide a unified OpenAI-compatible proxy
+ * for 50+ LLM providers via API keys.
+ * 
+ * Port: 8318 (different from CLIProxyAPI which uses 8317)
+ * 
+ * Supported providers (API Key only):
+ * - MiniMax, DeepSeek, Groq, Mistral, xAI, Perplexity, OpenRouter
+ * - And 50+ more via LiteLLM
+ */
+
+const { LLMProxyManager } = require('./manager');
+
+// Singleton instance
+let proxyManager = null;
+
+/**
+ * Get or create proxy manager instance
+ * @returns {LLMProxyManager}
+ */
+const getManager = () => {
+  if (!proxyManager) {
+    proxyManager = new LLMProxyManager();
+  }
+  return proxyManager;
+};
+
+/**
+ * Check if LLM Proxy is installed (Python venv + LiteLLM)
+ * @returns {boolean}
+ */
+const isInstalled = () => {
+  return getManager().isInstalled();
+};
+
+/**
+ * Install LLM Proxy (creates Python venv, installs LiteLLM)
+ * @param {Function} onProgress - Progress callback (message, percent)
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+const install = async (onProgress = () => {}) => {
+  return getManager().install(onProgress);
+};
+
+/**
+ * Check if LLM Proxy is running
+ * @returns {Promise<{running: boolean, port?: number}>}
+ */
+const isRunning = async () => {
+  return getManager().isRunning();
+};
+
+/**
+ * Start LLM Proxy server
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+const start = async () => {
+  return getManager().start();
+};
+
+/**
+ * Stop LLM Proxy server
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+const stop = async () => {
+  return getManager().stop();
+};
+
+/**
+ * Set API key for a provider
+ * @param {string} providerId - Provider ID (e.g., 'minimax', 'deepseek')
+ * @param {string} apiKey - API key
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+const setApiKey = async (providerId, apiKey) => {
+  return getManager().setApiKey(providerId, apiKey);
+};
+
+/**
+ * Get API key for a provider
+ * @param {string} providerId - Provider ID
+ * @returns {string|null}
+ */
+const getApiKey = (providerId) => {
+  return getManager().getApiKey(providerId);
+};
+
+/**
+ * Test connection to a provider
+ * @param {string} providerId - Provider ID
+ * @param {string} modelId - Model ID to test
+ * @returns {Promise<{success: boolean, latency?: number, error?: string}>}
+ */
+const testConnection = async (providerId, modelId) => {
+  return getManager().testConnection(providerId, modelId);
+};
+
+/**
+ * Make a chat completion request via LLM Proxy
+ * @param {string} providerId - Provider ID
+ * @param {string} modelId - Model ID
+ * @param {Array} messages - Chat messages
+ * @param {Object} options - Additional options (temperature, max_tokens, etc.)
+ * @returns {Promise<{success: boolean, response?: Object, error?: string}>}
+ */
+const chatCompletion = async (providerId, modelId, messages, options = {}) => {
+  return getManager().chatCompletion(providerId, modelId, messages, options);
+};
+
+/**
+ * Get LLM Proxy base URL
+ * @returns {string}
+ */
+const getBaseUrl = () => {
+  return getManager().getBaseUrl();
+};
+
+/**
+ * Get port
+ * @returns {number}
+ */
+const getPort = () => {
+  return getManager().port;
+};
+
+/**
+ * Provider mapping for LiteLLM model prefixes
+ */
+const PROVIDER_PREFIXES = {
+  minimax: 'minimax/',
+  deepseek: 'deepseek/',
+  groq: 'groq/',
+  mistral: 'mistral/',
+  xai: 'xai/',
+  perplexity: 'perplexity/',
+  openrouter: 'openrouter/',
+  together: 'together_ai/',
+  anyscale: 'anyscale/',
+  fireworks: 'fireworks_ai/',
+  cohere: 'cohere/',
+  ai21: 'ai21/',
+  nlp_cloud: 'nlp_cloud/',
+  replicate: 'replicate/',
+  bedrock: 'bedrock/',
+  sagemaker: 'sagemaker/',
+  vertex: 'vertex_ai/',
+  palm: 'palm/',
+  azure: 'azure/',
+};
+
+module.exports = {
+  isInstalled,
+  install,
+  isRunning,
+  start,
+  stop,
+  setApiKey,
+  getApiKey,
+  testConnection,
+  chatCompletion,
+  getBaseUrl,
+  getPort,
+  PROVIDER_PREFIXES,
+};

package/src/services/llmproxy/manager.js

@@ -0,0 +1,411 @@
+/**
+ * LLM Proxy Manager
+ * 
+ * Manages LiteLLM proxy server installation, configuration and lifecycle.
+ * Uses Python virtual environment for isolation.
+ */
+
+const { spawn, execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const http = require('http');
+
+// Configuration
+const LLMPROXY_DIR = path.join(os.homedir(), '.hqx', 'llmproxy');
+const VENV_DIR = path.join(LLMPROXY_DIR, 'venv');
+const ENV_FILE = path.join(LLMPROXY_DIR, '.env');
+const PID_FILE = path.join(LLMPROXY_DIR, 'llmproxy.pid');
+const LOG_FILE = path.join(LLMPROXY_DIR, 'llmproxy.log');
+const DEFAULT_PORT = 8318;
+
+/**
+ * LLM Proxy Manager Class
+ */
+class LLMProxyManager {
+  constructor() {
+    this.port = DEFAULT_PORT;
+    this.process = null;
+  }
+
+  /**
+   * Get Python executable path in venv
+   */
+  getPythonPath() {
+    const isWindows = process.platform === 'win32';
+    return isWindows
+      ? path.join(VENV_DIR, 'Scripts', 'python.exe')
+      : path.join(VENV_DIR, 'bin', 'python');
+  }
+
+  /**
+   * Get pip executable path in venv
+   */
+  getPipPath() {
+    const isWindows = process.platform === 'win32';
+    return isWindows
+      ? path.join(VENV_DIR, 'Scripts', 'pip.exe')
+      : path.join(VENV_DIR, 'bin', 'pip');
+  }
+
+  /**
+   * Check if LLM Proxy is installed
+   */
+  isInstalled() {
+    try {
+      const pythonPath = this.getPythonPath();
+      if (!fs.existsSync(pythonPath)) return false;
+      
+      // Check if litellm is installed
+      execSync(`"${pythonPath}" -c "import litellm"`, { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Install LLM Proxy (Python venv + LiteLLM)
+   */
+  async install(onProgress = () => {}) {
+    try {
+      // Create directory
+      if (!fs.existsSync(LLMPROXY_DIR)) {
+        fs.mkdirSync(LLMPROXY_DIR, { recursive: true });
+      }
+      
+      onProgress('Creating Python virtual environment', 10);
+      
+      // Check for Python
+      let pythonCmd = 'python3';
+      try {
+        execSync('python3 --version', { stdio: 'ignore' });
+      } catch {
+        try {
+          execSync('python --version', { stdio: 'ignore' });
+          pythonCmd = 'python';
+        } catch {
+          return { success: false, error: 'Python not found. Install Python 3.8+' };
+        }
+      }
+      
+      // Create venv
+      if (!fs.existsSync(VENV_DIR)) {
+        execSync(`${pythonCmd} -m venv "${VENV_DIR}"`, { stdio: 'ignore' });
+      }
+      
+      onProgress('Installing LiteLLM', 40);
+      
+      // Install litellm
+      const pipPath = this.getPipPath();
+      execSync(`"${pipPath}" install --upgrade pip`, { stdio: 'ignore' });
+      execSync(`"${pipPath}" install litellm[proxy]`, { stdio: 'ignore', timeout: 300000 });
+      
+      onProgress('Installation complete', 100);
+      
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Check if LLM Proxy is running
+   */
+  async isRunning() {
+    try {
+      // Check PID file
+      if (fs.existsSync(PID_FILE)) {
+        const pid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim());
+        try {
+          process.kill(pid, 0); // Check if process exists
+          // Verify it's responding
+          const health = await this.healthCheck();
+          if (health.success) {
+            return { running: true, port: this.port, pid };
+          }
+        } catch {
+          // PID exists but process doesn't - clean up
+          fs.unlinkSync(PID_FILE);
+        }
+      }
+      return { running: false };
+    } catch {
+      return { running: false };
+    }
+  }
+
+  /**
+   * Health check - ping the proxy
+   */
+  healthCheck() {
+    return new Promise((resolve) => {
+      const req = http.request({
+        hostname: 'localhost',
+        port: this.port,
+        path: '/health',
+        method: 'GET',
+        timeout: 5000
+      }, (res) => {
+        resolve({ success: res.statusCode === 200 });
+      });
+      req.on('error', () => resolve({ success: false }));
+      req.on('timeout', () => { req.destroy(); resolve({ success: false }); });
+      req.end();
+    });
+  }
+
+  /**
+   * Load environment variables from .env file
+   */
+  loadEnvFile() {
+    if (!fs.existsSync(ENV_FILE)) return {};
+    const content = fs.readFileSync(ENV_FILE, 'utf8');
+    const env = {};
+    for (const line of content.split('\n')) {
+      const match = line.match(/^([^=]+)=(.*)$/);
+      if (match) {
+        env[match[1].trim()] = match[2].trim();
+      }
+    }
+    return env;
+  }
+
+  /**
+   * Save environment variable to .env file
+   */
+  saveEnvVar(key, value) {
+    const env = this.loadEnvFile();
+    env[key] = value;
+    const content = Object.entries(env)
+      .map(([k, v]) => `${k}=${v}`)
+      .join('\n');
+    fs.writeFileSync(ENV_FILE, content);
+  }
+
+  /**
+   * Start LLM Proxy server
+   */
+  async start() {
+    try {
+      // Check if already running
+      const status = await this.isRunning();
+      if (status.running) {
+        return { success: true, message: 'Already running' };
+      }
+
+      if (!this.isInstalled()) {
+        return { success: false, error: 'LLM Proxy not installed. Run install() first.' };
+      }
+
+      const pythonPath = this.getPythonPath();
+      const env = { ...process.env, ...this.loadEnvFile() };
+      
+      // Start LiteLLM proxy
+      const proc = spawn(pythonPath, [
+        '-m', 'litellm',
+        '--port', String(this.port),
+        '--host', '0.0.0.0'
+      ], {
+        cwd: LLMPROXY_DIR,
+        env,
+        detached: true,
+        stdio: ['ignore', 'pipe', 'pipe']
+      });
+
+      // Write logs
+      const logStream = fs.createWriteStream(LOG_FILE, { flags: 'a' });
+      proc.stdout.pipe(logStream);
+      proc.stderr.pipe(logStream);
+
+      // Save PID
+      fs.writeFileSync(PID_FILE, String(proc.pid));
+      proc.unref();
+      
+      // Wait for startup
+      await new Promise(r => setTimeout(r, 3000));
+      
+      // Verify running
+      const health = await this.healthCheck();
+      if (!health.success) {
+        return { success: false, error: 'Proxy started but not responding' };
+      }
+
+      return { success: true, port: this.port, pid: proc.pid };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Stop LLM Proxy server
+   */
+  async stop() {
+    try {
+      if (fs.existsSync(PID_FILE)) {
+        const pid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim());
+        try {
+          process.kill(pid, 'SIGTERM');
+          await new Promise(r => setTimeout(r, 1000));
+          try { process.kill(pid, 'SIGKILL'); } catch {}
+        } catch {}
+        fs.unlinkSync(PID_FILE);
+      }
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Set API key for a provider
+   */
+  async setApiKey(providerId, apiKey) {
+    try {
+      const envKey = this.getEnvKeyName(providerId);
+      this.saveEnvVar(envKey, apiKey);
+      
+      // Restart proxy if running to pick up new key
+      const status = await this.isRunning();
+      if (status.running) {
+        await this.stop();
+        await this.start();
+      }
+      
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Get API key for a provider
+   */
+  getApiKey(providerId) {
+    const envKey = this.getEnvKeyName(providerId);
+    const env = this.loadEnvFile();
+    return env[envKey] || null;
+  }
+
+  /**
+   * Get environment variable name for provider API key
+   */
+  getEnvKeyName(providerId) {
+    const mapping = {
+      minimax: 'MINIMAX_API_KEY',
+      deepseek: 'DEEPSEEK_API_KEY',
+      groq: 'GROQ_API_KEY',
+      mistral: 'MISTRAL_API_KEY',
+      xai: 'XAI_API_KEY',
+      perplexity: 'PERPLEXITYAI_API_KEY',
+      openrouter: 'OPENROUTER_API_KEY',
+      together: 'TOGETHERAI_API_KEY',
+      fireworks: 'FIREWORKS_AI_API_KEY',
+      cohere: 'COHERE_API_KEY',
+      ai21: 'AI21_API_KEY',
+      replicate: 'REPLICATE_API_KEY',
+      anthropic: 'ANTHROPIC_API_KEY',
+      openai: 'OPENAI_API_KEY',
+      google: 'GEMINI_API_KEY',
+    };
+    return mapping[providerId] || `${providerId.toUpperCase()}_API_KEY`;
+  }
+
+  /**
+   * Test connection to a provider
+   */
+  async testConnection(providerId, modelId) {
+    try {
+      const start = Date.now();
+      const result = await this.chatCompletion(providerId, modelId, [
+        { role: 'user', content: 'Say "OK" in one word.' }
+      ], { max_tokens: 5 });
+      
+      if (result.success) {
+        return { success: true, latency: Date.now() - start };
+      }
+      return { success: false, error: result.error };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Make chat completion request via LLM Proxy
+   */
+  async chatCompletion(providerId, modelId, messages, options = {}) {
+    return new Promise((resolve) => {
+      const modelPrefix = this.getModelPrefix(providerId);
+      const fullModelId = modelId.includes('/') ? modelId : `${modelPrefix}${modelId}`;
+      
+      const body = JSON.stringify({
+        model: fullModelId,
+        messages,
+        ...options
+      });
+
+      const req = http.request({
+        hostname: 'localhost',
+        port: this.port,
+        path: '/v1/chat/completions',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(body)
+        },
+        timeout: 60000
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          try {
+            const parsed = JSON.parse(data);
+            if (res.statusCode >= 200 && res.statusCode < 300) {
+              resolve({ success: true, response: parsed });
+            } else {
+              resolve({ success: false, error: parsed.error?.message || `HTTP ${res.statusCode}` });
+            }
+          } catch {
+            resolve({ success: false, error: 'Invalid response' });
+          }
+        });
+      });
+
+      req.on('error', (err) => resolve({ success: false, error: err.message }));
+      req.on('timeout', () => { req.destroy(); resolve({ success: false, error: 'Timeout' }); });
+      req.write(body);
+      req.end();
+    });
+  }
+
+  /**
+   * Get LiteLLM model prefix for provider
+   */
+  getModelPrefix(providerId) {
+    const prefixes = {
+      minimax: 'minimax/',
+      deepseek: 'deepseek/',
+      groq: 'groq/',
+      mistral: 'mistral/',
+      xai: 'xai/',
+      perplexity: 'perplexity/',
+      openrouter: 'openrouter/',
+      together: 'together_ai/',
+      fireworks: 'fireworks_ai/',
+      cohere: 'cohere/',
+      anthropic: 'anthropic/',
+      openai: 'openai/',
+      google: 'gemini/',
+    };
+    return prefixes[providerId] || `${providerId}/`;
+  }
+
+  /**
+   * Get base URL for LLM Proxy
+   */
+  getBaseUrl() {
+    return `http://localhost:${this.port}`;
+  }
+}
+
+module.exports = { LLMProxyManager };