hedgequantx 2.9.32 → 2.9.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.9.32",
+  "version": "2.9.34",
   "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) {

package/src/services/rithmic/orders.js

@@ -292,33 +292,64 @@ const getOrderHistory = async (service, date) => {
 };
 
 /**
- * Get full trade history for multiple dates
+ * Get full trade history (fills) from ORDER_PLANT
  * @param {RithmicService} service - The Rithmic service instance
- * @param {number} days - Number of days to fetch (default 30)
+ * @param {number} days - Number of days to fetch (default 7, max 14)
  * @returns {Promise<{success: boolean, trades: Array}>}
  */
-const getTradeHistoryFull = async (service, days = 30) => {
+const getTradeHistoryFull = async (service, days = 7) => {
   if (!service.orderConn || !service.loginInfo) {
     return { success: false, trades: [] };
   }
 
-  // Get available dates
-  const { dates } = await getOrderHistoryDates(service);
+  // Get available dates with timeout
+  let dates;
+  try {
+    const datesPromise = getOrderHistoryDates(service);
+    const timeoutPromise = new Promise((_, reject) => 
+      setTimeout(() => reject(new Error('Timeout')), 5000)
+    );
+    const result = await Promise.race([datesPromise, timeoutPromise]);
+    dates = result.dates;
+  } catch (e) {
+    return { success: true, trades: [] };
+  }
+  
   if (!dates || dates.length === 0) {
     return { success: true, trades: [] };
   }
 
-  // Sort dates descending and limit to requested days
-  const sortedDates = dates.sort((a, b) => b.localeCompare(a)).slice(0, days);
+  // Filter to recent dates only (last N days from today)
+  const today = new Date();
+  const cutoffDate = new Date(today.getTime() - (Math.min(days, 14) * 24 * 60 * 60 * 1000));
+  const cutoffStr = cutoffDate.toISOString().slice(0, 10).replace(/-/g, '');
+  
+  // Sort dates descending and filter to recent only
+  const recentDates = dates
+    .filter(d => d >= cutoffStr)
+    .sort((a, b) => b.localeCompare(a))
+    .slice(0, 7); // Max 7 dates to avoid long waits
+  
+  if (recentDates.length === 0) {
+    return { success: true, trades: [] };
+  }
   
   const allTrades = [];
   
-  // Fetch history for each date
-  for (const date of sortedDates) {
-    const { orders } = await getOrderHistory(service, date);
-    // Filter only fills (notifyType 5)
-    const fills = orders.filter(o => o.notifyType === 5 || o.fillPrice);
-    allTrades.push(...fills);
+  // Fetch history for each date with short timeout
+  for (const date of recentDates) {
+    try {
+      const histPromise = getOrderHistory(service, date);
+      const timeoutPromise = new Promise((resolve) => 
+        setTimeout(() => resolve({ orders: [] }), 3000)
+      );
+      const { orders } = await Promise.race([histPromise, timeoutPromise]);
+      // Filter only fills (notifyType 5)
+      const fills = (orders || []).filter(o => o.notifyType === 5 || o.fillPrice);
+      allTrades.push(...fills);
+    } catch (e) {
+      // Skip failed dates
+    }
   }
 
   return { success: true, trades: allTrades };