hedgequantx 2.9.32 → 2.9.33

package/package.json

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

package/src/app.js

@@ -77,7 +77,10 @@ const refreshStats = async () => {
 
   try {
     const allAccounts = await connections.getAllAccounts();
-    const activeAccounts = allAccounts.filter(acc => acc.status === 0);
+    // Filter active accounts: status === 0 (ProjectX) OR status === 'active' (Rithmic) OR no status
+    const activeAccounts = allAccounts.filter(acc => 
+      acc.status === 0 || acc.status === 'active' || acc.status === undefined || acc.status === null
+    );
 
     let totalBalance = null;
     let totalPnl = null;

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

@@ -113,50 +113,75 @@ const testApiKeyConnection = async (agent) => {
 
 /**
  * Test a single agent connection and response format
+ * Includes retry logic for non-deterministic agents (like MiniMax)
  * @param {Object} agent - Agent config { id, provider, modelId, connectionType, apiKey, ... }
+ * @param {number} maxRetries - Maximum retry attempts (default 2)
  * @returns {Promise<Object>} { success, latency, formatValid, error }
  */
-const testAgentConnection = async (agent) => {
-  const startTime = Date.now();
+const testAgentConnection = async (agent, maxRetries = 2) => {
+  let lastResult = null;
   
-  try {
-    // Route based on connection type
-    if (agent.connectionType === 'apikey') {
-      return await testApiKeyConnection(agent);
-    }
-    
-    // CLIProxy connection
-    const result = await cliproxy.chat(agent.provider, agent.modelId, TEST_PROMPT, AGENT_TIMEOUT);
-    const latency = Date.now() - startTime;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    const startTime = Date.now();
     
-    if (!result.success) {
-      return {
+    try {
+      // Route based on connection type
+      if (agent.connectionType === 'apikey') {
+        lastResult = await testApiKeyConnection(agent);
+      } else {
+        // CLIProxy connection
+        const result = await cliproxy.chat(agent.provider, agent.modelId, TEST_PROMPT, AGENT_TIMEOUT);
+        const latency = Date.now() - startTime;
+        
+        if (!result.success) {
+          lastResult = {
+            success: false,
+            latency,
+            formatValid: false,
+            error: result.error || 'No response from agent'
+          };
+        } else {
+          // Validate response format
+          const formatResult = validateResponseFormat(result.content);
+          
+          lastResult = {
+            success: formatResult.valid,
+            latency,
+            formatValid: formatResult.valid,
+            error: formatResult.valid ? null : formatResult.error,
+            response: result.content
+          };
+        }
+      }
+      
+      // If successful, return immediately
+      if (lastResult.success) {
+        return lastResult;
+      }
+      
+      // Only retry on format errors (not connection errors)
+      if (lastResult.error && !lastResult.error.includes('valid JSON') && 
+          !lastResult.error.includes('Missing') && !lastResult.error.includes('Invalid')) {
+        // Connection error - don't retry
+        return lastResult;
+      }
+      
+      // Wait a bit before retry
+      if (attempt < maxRetries) {
+        await new Promise(r => setTimeout(r, 500));
+      }
+      
+    } catch (error) {
+      lastResult = {
         success: false,
-        latency,
+        latency: Date.now() - startTime,
         formatValid: false,
-        error: result.error || 'No response from agent'
+        error: error.message || 'Connection failed'
       };
     }
-    
-    // Validate response format
-    const formatResult = validateResponseFormat(result.content);
-    
-    return {
-      success: formatResult.valid,
-      latency,
-      formatValid: formatResult.valid,
-      error: formatResult.valid ? null : formatResult.error,
-      response: result.content
-    };
-    
-  } catch (error) {
-    return {
-      success: false,
-      latency: Date.now() - startTime,
-      formatValid: false,
-      error: error.message || 'Connection failed'
-    };
   }
+  
+  return lastResult;
 };
 
 /**

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

@@ -37,8 +37,13 @@ const extractJSON = (text) => {
     } catch (e) { /* continue */ }
   }
 
-  // Remove <think>...</think> tags (MiniMax)
-  let cleaned = text.replace(/<think>[\s\S]*?<\/think>/gi, '').trim();
+  // Remove <think>...</think> tags (MiniMax) - multiple patterns
+  let cleaned = text
+    .replace(/<think>[\s\S]*?<\/think>/gi, '')
+    .replace(/<thinking>[\s\S]*?<\/thinking>/gi, '')
+    .replace(/<reasoning>[\s\S]*?<\/reasoning>/gi, '')
+    .replace(/<analysis>[\s\S]*?<\/analysis>/gi, '')
+    .trim();
   
   // Try to parse cleaned text
   try {
@@ -50,14 +55,37 @@ const extractJSON = (text) => {
   if (startIdx !== -1) {
     let depth = 0;
     let endIdx = -1;
+    let inString = false;
+    let escapeNext = false;
+    
     for (let i = startIdx; i < cleaned.length; i++) {
-      if (cleaned[i] === '{') depth++;
-      if (cleaned[i] === '}') depth--;
-      if (depth === 0) {
-        endIdx = i;
-        break;
+      const char = cleaned[i];
+      
+      if (escapeNext) {
+        escapeNext = false;
+        continue;
+      }
+      
+      if (char === '\\') {
+        escapeNext = true;
+        continue;
+      }
+      
+      if (char === '"') {
+        inString = !inString;
+        continue;
+      }
+      
+      if (!inString) {
+        if (char === '{') depth++;
+        if (char === '}') depth--;
+        if (depth === 0) {
+          endIdx = i;
+          break;
+        }
       }
     }
+    
     if (endIdx !== -1) {
       try {
         return JSON.parse(cleaned.substring(startIdx, endIdx + 1));
@@ -65,6 +93,19 @@ const extractJSON = (text) => {
     }
   }
 
+  // Try to extract just decision/confidence/reason pattern
+  const decisionMatch = cleaned.match(/"decision"\s*:\s*"(approve|reject|modify)"/i);
+  const confidenceMatch = cleaned.match(/"confidence"\s*:\s*(\d+)/);
+  const reasonMatch = cleaned.match(/"reason"\s*:\s*"([^"]+)"/);
+  
+  if (decisionMatch && confidenceMatch) {
+    return {
+      decision: decisionMatch[1].toLowerCase(),
+      confidence: parseInt(confidenceMatch[1]),
+      reason: reasonMatch ? reasonMatch[1] : 'Extracted from partial response'
+    };
+  }
+
   // Last resort: try to find JSON object pattern with "decision"
   const jsonMatch = cleaned.match(/\{[^{}]*"decision"[^{}]*\}/);
   if (jsonMatch) {