hedgequantx 2.9.2 → 2.9.4

package/package.json

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

package/src/pages/ai-agents.js

@@ -34,8 +34,8 @@ const AI_PROVIDERS = [
   { id: 'iflow', name: 'iFlow (DeepSeek/GLM)', color: 'yellow', supportsOAuth: true, supportsApiKey: true },
   // API Key only (no OAuth - uses LLM Proxy via LiteLLM)
   { id: 'minimax', name: 'MiniMax', color: 'magenta', supportsOAuth: false, supportsApiKey: true },
+  { id: 'deepseek', name: 'DeepSeek', color: 'blue', 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: 'openrouter', name: 'OpenRouter', color: 'gray', supportsOAuth: false, supportsApiKey: true },
 ];

package/src/pages/ai-models.js

@@ -16,8 +16,8 @@ const API_ENDPOINTS = {
   openai: 'https://api.openai.com/v1/models',
   google: 'https://generativelanguage.googleapis.com/v1beta/models',
   minimax: null, // No /models API - uses MINIMAX_MODELS (see RULES.md exception)
+  deepseek: 'https://api.deepseek.com/v1/models',
   mistral: 'https://api.mistral.ai/v1/models',
-  groq: 'https://api.groq.com/openai/v1/models',
   xai: 'https://api.x.ai/v1/models',
   openrouter: 'https://openrouter.ai/api/v1/models',
 };
@@ -98,9 +98,7 @@ const getAuthHeaders = (providerId, apiKey) => {
     case 'openai':
     case 'deepseek':
     case 'minimax':
-    case 'groq':
     case 'xai':
-    case 'perplexity':
     case 'openrouter':
     case 'mistral':
       return { 'Authorization': `Bearer ${apiKey}` };
@@ -237,16 +235,6 @@ const parseModelsResponse = (providerId, data) => {
           }));
         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 || [])

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:
+ * - CLIProxy (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:
@@ -39,28 +40,105 @@ const checkCliproxyRunning = async () => {
   }
 };
 
+/**
+ * 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: 'CLIProxy 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('CLIProxy Status', chalk.green('✓ RUNNING')));
+    } else {
+      lines.push(dottedLine('CLIProxy Status', 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('✗ CLIProxy not running - some agents cannot be verified'),
       success: false
     };
   }