hedgequantx 2.9.3 → 2.9.5

package/package.json

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

package/src/pages/ai-agents.js

@@ -1,4 +1,4 @@
-/** AI Agents Configuration Page - CLIProxy (OAuth) + LLM Proxy (API Key) */
+/** AI Agents Configuration Page - HQX Connector (OAuth) + API Key */
 
 const chalk = require('chalk');
 const os = require('os');
@@ -23,8 +23,8 @@ const CONFIG_DIR = path.join(os.homedir(), '.hqx');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'ai-config.json');
 
 // 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
+// HQX Connector (port 8317): OAuth for Anthropic, OpenAI, Google, Qwen, iFlow
+// Direct API Key: For MiniMax, DeepSeek, Mistral, xAI, OpenRouter
 const AI_PROVIDERS = [
   // OAuth + API Key supported (can use paid plan OR API key)
   { id: 'anthropic', name: 'Anthropic (Claude)', color: 'magenta', supportsOAuth: true, supportsApiKey: true },
@@ -116,33 +116,33 @@ const waitForProcessExit = (cp, timeoutMs = 15000, intervalMs = 500) => new Prom
   }, intervalMs);
 });
 
-/** Handle CLIProxy connection (with auto-install) */
+/** Handle HQX Connector connection (with auto-install) */
 const handleCliProxyConnection = async (provider, config, boxWidth) => {
   console.log();
-  // Check/install CLIProxyAPI
+  // Check/install HQX Connector
   if (!cliproxy.isInstalled()) {
-    console.log(chalk.yellow('  CLIPROXYAPI NOT INSTALLED. INSTALLING...'));
+    console.log(chalk.yellow('  HQX CONNECTOR NOT INSTALLED. INSTALLING...'));
     const spinner = ora({ text: 'DOWNLOADING...', color: 'yellow' }).start();
     const installResult = await cliproxy.install((msg, percent) => { spinner.text = `${msg.toUpperCase()} ${percent}%`; });
     if (!installResult.success) { spinner.fail(`INSTALL FAILED: ${installResult.error}`); await prompts.waitForEnter(); return false; }
-    spinner.succeed('CLIPROXYAPI INSTALLED');
+    spinner.succeed('HQX CONNECTOR INSTALLED');
   }
-  // Check/start CLIProxy
+  // Check/start HQX Connector
   let status = await cliproxy.isRunning();
   if (!status.running) {
-    const spinner = ora({ text: 'STARTING CLIPROXYAPI...', color: 'yellow' }).start();
+    const spinner = ora({ text: 'STARTING HQX CONNECTOR...', color: 'yellow' }).start();
     const startResult = await cliproxy.start();
     if (!startResult.success) { spinner.fail(`START FAILED: ${startResult.error}`); await prompts.waitForEnter(); return false; }
-    spinner.succeed('CLIPROXYAPI STARTED');
+    spinner.succeed('HQX CONNECTOR STARTED');
   } else {
     const cfgPath = path.join(os.homedir(), '.hqx', 'cliproxy', 'config.yaml');
     if (!fs.existsSync(cfgPath)) {
-      console.log(chalk.yellow('  RESTARTING CLIPROXYAPI...'));
+      console.log(chalk.yellow('  RESTARTING HQX CONNECTOR...'));
       await cliproxy.stop();
       const res = await cliproxy.start();
       if (!res.success) { console.log(chalk.red(`  RESTART FAILED: ${res.error}`)); await prompts.waitForEnter(); return false; }
       console.log(chalk.green('  ✓ RESTARTED'));
-    } else console.log(chalk.green('  ✓ CLIPROXYAPI RUNNING'));
+    } else console.log(chalk.green('  ✓ HQX CONNECTOR RUNNING'));
   }
   
   // First, check if models are already available (existing auth)

package/src/services/ai-supervision/health.js

@@ -4,12 +4,13 @@
  * Verifies that AI agents are properly connected and responding
  * before allowing algo trading with AI supervision.
  * 
- * Two verification points:
- * 1. [T] TEST in AI Agents menu - manual verification
- * 2. Pre-check before algo launch - automatic verification
+ * Supports both connection types:
+ * - HQX Connector (OAuth) for Anthropic, OpenAI, Google, Qwen, iFlow
+ * - Direct API Key for MiniMax, DeepSeek, Mistral, xAI, OpenRouter
  */
 
 const cliproxy = require('../cliproxy');
+const https = require('https');
 
 /** Test prompt to verify agent understands directive format */
 const TEST_PROMPT = `You are being tested. Respond ONLY with this exact JSON, nothing else:
@@ -33,34 +34,111 @@ const checkCliproxyRunning = async () => {
       return { success: true, latency, error: null };
     }
     
-    return { success: false, latency, error: 'CLIProxy not running' };
+    return { success: false, latency, error: 'HQX Connector not running' };
   } catch (error) {
     return { success: false, latency: Date.now() - startTime, error: error.message };
   }
 };
 
+/**
+ * API endpoints for direct API key providers
+ */
+const API_CHAT_ENDPOINTS = {
+  minimax: 'https://api.minimax.io/v1/chat/completions',
+  deepseek: 'https://api.deepseek.com/v1/chat/completions',
+  mistral: 'https://api.mistral.ai/v1/chat/completions',
+  xai: 'https://api.x.ai/v1/chat/completions',
+  openrouter: 'https://openrouter.ai/api/v1/chat/completions',
+};
+
+/**
+ * Test connection via direct API key
+ * @param {Object} agent - Agent config
+ * @returns {Promise<Object>} { success, latency, formatValid, error }
+ */
+const testApiKeyConnection = (agent) => {
+  return new Promise((resolve) => {
+    const startTime = Date.now();
+    const endpoint = API_CHAT_ENDPOINTS[agent.provider];
+    
+    if (!endpoint || !agent.apiKey) {
+      resolve({ success: false, latency: 0, formatValid: false, error: 'Missing endpoint or API key' });
+      return;
+    }
+    
+    const url = new URL(endpoint);
+    const body = JSON.stringify({
+      model: agent.modelId,
+      messages: [{ role: 'user', content: TEST_PROMPT }],
+      max_tokens: 100
+    });
+    
+    const options = {
+      hostname: url.hostname,
+      path: url.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${agent.apiKey}`,
+        'Content-Length': Buffer.byteLength(body)
+      },
+      timeout: AGENT_TIMEOUT
+    };
+    
+    const req = https.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        const latency = Date.now() - startTime;
+        try {
+          const parsed = JSON.parse(data);
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            const content = parsed.choices?.[0]?.message?.content || '';
+            const formatResult = validateResponseFormat(content);
+            resolve({
+              success: formatResult.valid,
+              latency,
+              formatValid: formatResult.valid,
+              error: formatResult.valid ? null : formatResult.error,
+              response: content
+            });
+          } else {
+            resolve({ success: false, latency, formatValid: false, 
+              error: parsed.error?.message || `HTTP ${res.statusCode}` });
+          }
+        } catch (e) {
+          resolve({ success: false, latency, formatValid: false, error: 'Invalid response' });
+        }
+      });
+    });
+    
+    req.on('error', (e) => resolve({ 
+      success: false, latency: Date.now() - startTime, formatValid: false, error: e.message 
+    }));
+    req.on('timeout', () => { 
+      req.destroy(); 
+      resolve({ success: false, latency: AGENT_TIMEOUT, formatValid: false, error: 'Timeout' }); 
+    });
+    req.write(body);
+    req.end();
+  });
+};
+
 /**
  * Test a single agent connection and response format
- * @param {Object} agent - Agent config { id, provider, modelId, connectionType, ... }
+ * @param {Object} agent - Agent config { id, provider, modelId, connectionType, apiKey, ... }
  * @returns {Promise<Object>} { success, latency, formatValid, error }
  */
 const testAgentConnection = async (agent) => {
   const startTime = Date.now();
   
   try {
-    // Only test CLIProxy connections for now
-    if (agent.connectionType !== 'cliproxy') {
-      // For API key connections, we would need different logic
-      // For now, mark as needing CLIProxy
-      return {
-        success: false,
-        latency: 0,
-        formatValid: false,
-        error: 'Only CLIProxy connections supported for pre-check'
-      };
+    // Route based on connection type
+    if (agent.connectionType === 'apikey') {
+      return await testApiKeyConnection(agent);
     }
     
-    // Send test prompt with short timeout
+    // CLIProxy connection
     const result = await cliproxy.chat(agent.provider, agent.modelId, TEST_PROMPT, AGENT_TIMEOUT);
     const latency = Date.now() - startTime;
     
@@ -156,29 +234,53 @@ const validateResponseFormat = (content) => {
 /**
  * Run pre-flight check on all agents
  * @param {Array} agents - Array of agent configs
- * @returns {Promise<Object>} { success, cliproxy, agents, summary }
+ * @returns {Promise<Object>} { success, cliproxy, needsCliproxy, agents, summary }
  */
 const runPreflightCheck = async (agents) => {
   const results = {
     success: false,
     cliproxy: null,
+    needsCliproxy: false,
     agents: [],
     summary: { total: 0, passed: 0, failed: 0 }
   };
   
-  // Step 1: Check CLIProxy
-  results.cliproxy = await checkCliproxyRunning();
+  // Check if any agent needs CLIProxy (non-apikey connection)
+  results.needsCliproxy = agents.some(a => a.connectionType !== 'apikey');
   
-  if (!results.cliproxy.success) {
-    results.summary.total = agents.length;
-    results.summary.failed = agents.length;
-    return results;
+  // Step 1: Check CLIProxy only if needed
+  if (results.needsCliproxy) {
+    results.cliproxy = await checkCliproxyRunning();
+    if (!results.cliproxy.success) {
+      // Mark only CLIProxy agents as failed, still test API Key agents
+      results.summary.total = agents.length;
+    }
+  } else {
+    // No CLIProxy needed, mark as success
+    results.cliproxy = { success: true, latency: 0, error: null, notNeeded: true };
   }
   
   // Step 2: Test each agent
   results.summary.total = agents.length;
   
   for (const agent of agents) {
+    // Skip CLIProxy agents if CLIProxy is not running
+    if (agent.connectionType !== 'apikey' && !results.cliproxy.success) {
+      results.agents.push({
+        id: agent.id,
+        name: agent.name,
+        provider: agent.provider,
+        modelId: agent.modelId,
+        connectionType: agent.connectionType,
+        success: false,
+        latency: 0,
+        formatValid: false,
+        error: 'HQX Connector not running'
+      });
+      results.summary.failed++;
+      continue;
+    }
+    
     const agentResult = await testAgentConnection(agent);
     
     results.agents.push({
@@ -186,6 +288,7 @@ const runPreflightCheck = async (agents) => {
       name: agent.name,
       provider: agent.provider,
       modelId: agent.modelId,
+      connectionType: agent.connectionType,
       ...agentResult
     });
     
@@ -221,13 +324,13 @@ const formatPreflightResults = (results, boxWidth) => {
     return ' '.repeat(labelPad) + chalk.white(label) + chalk.gray('.'.repeat(Math.max(3, dotsLen))) + value;
   };
   
-  // CLIProxy status
-  if (results.cliproxy.success) {
-    lines.push(dottedLine('CLIProxy Status', chalk.green('✓ RUNNING')));
-  } else {
-    lines.push(dottedLine('CLIProxy Status', chalk.red('✗ NOT RUNNING')));
-    lines.push(chalk.red(`   Error: ${results.cliproxy.error}`));
-    return lines;
+  // CLIProxy status (only show if needed)
+  if (results.needsCliproxy) {
+    if (results.cliproxy.success) {
+      lines.push(dottedLine('HQX Connector', chalk.green('✓ RUNNING')));
+    } else {
+      lines.push(dottedLine('HQX Connector', chalk.red('✗ NOT RUNNING')));
+    }
   }
   
   lines.push('');
@@ -238,8 +341,9 @@ const formatPreflightResults = (results, boxWidth) => {
   for (let i = 0; i < results.agents.length; i++) {
     const agent = results.agents[i];
     const num = `[${i + 1}/${results.summary.total}]`;
+    const connType = agent.connectionType === 'apikey' ? 'API Key' : 'OAuth';
     
-    lines.push(chalk.cyan(`   ${num} ${agent.name} (${agent.modelId || agent.provider})`));
+    lines.push(chalk.cyan(`   ${num} ${agent.name} (${agent.modelId || agent.provider}) [${connType}]`));
     
     if (agent.success) {
       const latencyStr = `✓ OK ${agent.latency}ms`;
@@ -264,9 +368,10 @@ const formatPreflightResults = (results, boxWidth) => {
 const getPreflightSummary = (results) => {
   const chalk = require('chalk');
   
-  if (!results.cliproxy.success) {
+  // Only show CLIProxy error if it was needed and failed
+  if (results.needsCliproxy && !results.cliproxy.success) {
     return {
-      text: chalk.red('✗ CLIProxy not running - cannot verify agents'),
+      text: chalk.red('✗ HQX Connector not running - some agents cannot be verified'),
       success: false
     };
   }

package/src/services/cliproxy/manager.js

@@ -97,9 +97,9 @@ const install = async (onProgress = null) => {
     const archivePath = path.join(INSTALL_DIR, download.filename);
     
     // Download
-    if (onProgress) onProgress('Downloading CLIProxyAPI...', 0);
+    if (onProgress) onProgress('Downloading HQX Connector...', 0);
     await downloadFile(download.url, archivePath, (percent) => {
-      if (onProgress) onProgress('Downloading CLIProxyAPI...', percent);
+      if (onProgress) onProgress('Downloading HQX Connector...', percent);
     });
     
     // Extract
@@ -165,7 +165,7 @@ api-keys:
 /** Start CLIProxyAPI */
 const start = async () => {
   if (!isInstalled()) {
-    return { success: false, error: 'CLIProxyAPI not installed', pid: null };
+    return { success: false, error: 'HQX Connector not installed', pid: null };
   }
   
   const status = await isRunning();
@@ -204,7 +204,7 @@ const start = async () => {
       return { success: true, error: null, pid: child.pid };
     } else {
       // Read log for error details
-      let errorDetail = 'Failed to start CLIProxyAPI';
+      let errorDetail = 'Failed to start HQX Connector';
       if (fs.existsSync(logPath)) {
         const log = fs.readFileSync(logPath, 'utf8').slice(-500);
         if (log) errorDetail += `: ${log.split('\n').pop()}`;
@@ -274,13 +274,13 @@ const stop = async () => {
 /** Ensure CLIProxyAPI is installed and running */
 const ensureRunning = async (onProgress = null) => {
   if (!isInstalled()) {
-    if (onProgress) onProgress('Installing CLIProxyAPI...', 0);
+    if (onProgress) onProgress('Installing HQX Connector...', 0);
     const installResult = await install(onProgress);
     if (!installResult.success) return installResult;
   }
   const status = await isRunning();
   if (status.running) return { success: true, error: null };
-  if (onProgress) onProgress('Starting CLIProxyAPI...', 100);
+  if (onProgress) onProgress('Starting HQX Connector...', 100);
   return start();
 };