hedgequantx 2.6.161 → 2.6.162

package/src/services/ai/client-analysis.js

@@ -0,0 +1,194 @@
+/**
+ * @fileoverview AI Client - Trading Analysis Functions
+ * 
+ * Functions to analyze trading data with AI
+ * Uses callAI from client.js core
+ */
+
+/**
+ * Analyze trading data with AI
+ * @param {Function} callAI - The callAI function from client.js
+ * @param {Object} agent - AI agent
+ * @param {Object} data - Trading data from APIs
+ * @returns {Promise<Object|null>} Analysis result or null
+ */
+const analyzeTrading = async (callAI, agent, data) => {
+  if (!agent || !data) return null;
+  
+  const systemPrompt = `You are a professional trading analyst for prop firm futures trading.
+Analyze the provided real-time trading data and provide actionable insights.
+Be concise. Focus on risk management and optimization.
+Respond in JSON format with: { "action": "HOLD|REDUCE_SIZE|PAUSE|CONTINUE", "confidence": 0-100, "reason": "brief reason" }`;
+  
+  const prompt = `Current trading session data:
+- Account Balance: ${data.account?.balance ?? 'N/A'}
+- Today P&L: ${data.account?.profitAndLoss ?? 'N/A'}
+- Open Positions: ${data.positions?.length ?? 0}
+- Open Orders: ${data.orders?.length ?? 0}
+- Today Trades: ${data.trades?.length ?? 0}
+
+${data.positions?.length > 0 ? `Positions: ${JSON.stringify(data.positions.map(p => ({
+  symbol: p.symbol || p.contractId,
+  qty: p.quantity,
+  pnl: p.profitAndLoss
+})))}` : ''}
+
+Analyze and provide recommendation.`;
+
+  try {
+    const response = await callAI(agent, prompt, systemPrompt);
+    if (!response) return null;
+    
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      return JSON.parse(jsonMatch[0]);
+    }
+    
+    return null;
+  } catch (error) {
+    return null;
+  }
+};
+
+/**
+ * Analyze strategy performance and suggest optimizations
+ * @param {Function} callAI - The callAI function from client.js
+ * @param {Object} agent - AI agent
+ * @param {Object} performanceData - Strategy performance data
+ * @returns {Promise<Object|null>} Optimization suggestions
+ */
+const analyzePerformance = async (callAI, agent, performanceData) => {
+  if (!agent || !performanceData) return null;
+  
+  const systemPrompt = `You are an AI supervisor for HQX Ultra Scalping, a professional prop firm futures trading strategy.
+
+The strategy uses advanced mathematical models:
+- Order flow analysis (delta, cumulative delta, absorption)
+- Market microstructure (bid/ask imbalance, volume profile)
+- Statistical edge detection (z-score, standard deviation bands)
+- Dynamic risk management (Kelly criterion, volatility-adjusted sizing)
+
+Your job is to analyze performance data and suggest parameter optimizations.
+Be precise and actionable. Focus on improving win rate, reducing drawdown, and optimizing risk/reward.
+
+Respond ONLY in valid JSON format:
+{
+  "assessment": "brief performance assessment",
+  "winRateAnalysis": "analysis of win/loss patterns",
+  "riskAnalysis": "analysis of risk management",
+  "optimizations": [
+    { "param": "parameter_name", "current": "current_value", "suggested": "new_value", "reason": "why" }
+  ],
+  "marketCondition": "trending|ranging|volatile|calm",
+  "confidence": 0-100
+}`;
+  
+  const prompt = `STRATEGY PERFORMANCE DATA - ANALYZE AND OPTIMIZE
+
+Session Stats:
+- Trades: ${performanceData.trades || 0}
+- Wins: ${performanceData.wins || 0}
+- Losses: ${performanceData.losses || 0}
+- Win Rate: ${performanceData.winRate ? (performanceData.winRate * 100).toFixed(1) + '%' : 'N/A'}
+- Total P&L: $${performanceData.pnl?.toFixed(2) || '0.00'}
+- Avg Win: $${performanceData.avgWin?.toFixed(2) || 'N/A'}
+- Avg Loss: $${performanceData.avgLoss?.toFixed(2) || 'N/A'}
+- Largest Win: $${performanceData.largestWin?.toFixed(2) || 'N/A'}
+- Largest Loss: $${performanceData.largestLoss?.toFixed(2) || 'N/A'}
+- Max Drawdown: $${performanceData.maxDrawdown?.toFixed(2) || 'N/A'}
+- Profit Factor: ${performanceData.profitFactor?.toFixed(2) || 'N/A'}
+
+Current Parameters:
+- Position Size: ${performanceData.positionSize || 'N/A'} contracts
+- Daily Target: $${performanceData.dailyTarget || 'N/A'}
+- Max Risk: $${performanceData.maxRisk || 'N/A'}
+- Symbol: ${performanceData.symbol || 'N/A'}
+
+Recent Trades:
+${performanceData.recentTrades?.map(t => 
+  `- ${t.side} ${t.qty}x @ ${t.price} → P&L: $${t.pnl?.toFixed(2) || 'N/A'}`
+).join('\n') || 'No recent trades'}
+
+Market Context:
+- Volatility: ${performanceData.volatility || 'N/A'}
+- Trend: ${performanceData.trend || 'N/A'}
+- Session: ${performanceData.session || 'N/A'}
+
+Analyze and suggest optimizations to improve performance.`;
+
+  try {
+    const response = await callAI(agent, prompt, systemPrompt);
+    if (!response) return null;
+    
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      return JSON.parse(jsonMatch[0]);
+    }
+    
+    return null;
+  } catch (error) {
+    return null;
+  }
+};
+
+/**
+ * Get real-time trading advice based on current market conditions
+ * @param {Function} callAI - The callAI function from client.js
+ * @param {Object} agent - AI agent
+ * @param {Object} marketData - Current market data
+ * @returns {Promise<Object|null>} Trading advice
+ */
+const getMarketAdvice = async (callAI, agent, marketData) => {
+  if (!agent || !marketData) return null;
+  
+  const systemPrompt = `You are an AI supervisor for HQX Ultra Scalping futures strategy.
+Analyze real-time market data and provide actionable advice.
+Be concise and precise. The strategy will use your recommendations.
+
+Respond ONLY in valid JSON:
+{
+  "action": "AGGRESSIVE|NORMAL|CAUTIOUS|PAUSE",
+  "sizeMultiplier": 0.5-1.5,
+  "reason": "brief reason",
+  "confidence": 0-100
+}`;
+  
+  const prompt = `REAL-TIME MARKET ANALYSIS
+
+Current Price: ${marketData.price || 'N/A'}
+Bid: ${marketData.bid || 'N/A'} | Ask: ${marketData.ask || 'N/A'}
+Spread: ${marketData.spread || 'N/A'}
+Volume: ${marketData.volume || 'N/A'}
+Delta: ${marketData.delta || 'N/A'}
+Volatility: ${marketData.volatility || 'N/A'}
+
+Recent Price Action:
+- High: ${marketData.high || 'N/A'}
+- Low: ${marketData.low || 'N/A'}
+- Range: ${marketData.range || 'N/A'}
+
+Current Position: ${marketData.position || 'FLAT'}
+Session P&L: $${marketData.pnl?.toFixed(2) || '0.00'}
+
+What should the strategy do?`;
+
+  try {
+    const response = await callAI(agent, prompt, systemPrompt);
+    if (!response) return null;
+    
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      return JSON.parse(jsonMatch[0]);
+    }
+    
+    return null;
+  } catch (error) {
+    return null;
+  }
+};
+
+module.exports = {
+  analyzeTrading,
+  analyzePerformance,
+  getMarketAdvice,
+};

package/src/services/ai/client-models.js

@@ -0,0 +1,333 @@
+/**
+ * @fileoverview AI Client - Model Fetching Functions
+ * 
+ * Functions to fetch available models from various AI providers
+ * Data comes from provider APIs - NO hardcoded fallbacks
+ */
+
+const https = require('https');
+const http = require('http');
+
+/**
+ * Make HTTP request
+ * @param {string} url - Full URL
+ * @param {Object} options - Request options
+ * @returns {Promise<Object>} Response data
+ */
+const makeRequest = (url, options) => {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(url);
+    const protocol = parsedUrl.protocol === 'https:' ? https : http;
+    
+    const req = protocol.request(url, {
+      method: options.method || 'POST',
+      headers: options.headers || {},
+      timeout: options.timeout || 30000
+    }, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(json);
+          } else {
+            reject(new Error(json.error?.message || `HTTP ${res.statusCode}`));
+          }
+        } catch (e) {
+          reject(new Error(`Invalid JSON response: ${data.substring(0, 100)}`));
+        }
+      });
+    });
+    
+    req.on('error', reject);
+    req.on('timeout', () => reject(new Error('Request timeout')));
+    
+    if (options.body) {
+      req.write(JSON.stringify(options.body));
+    }
+    req.end();
+  });
+};
+
+/**
+ * Fetch available models from Anthropic API (API Key auth)
+ * @param {string} apiKey - API key
+ * @returns {Promise<Array|null>} Array of model IDs or null on error
+ */
+const fetchAnthropicModels = async (apiKey) => {
+  if (!apiKey) return null;
+  
+  const url = 'https://api.anthropic.com/v1/models';
+  
+  const headers = {
+    'x-api-key': apiKey,
+    'anthropic-version': '2023-06-01'
+  };
+  
+  try {
+    const response = await makeRequest(url, { method: 'GET', headers, timeout: 10000 });
+    if (response.data && Array.isArray(response.data)) {
+      return response.data.map(m => m.id).filter(Boolean);
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+};
+
+/**
+ * Fetch available models from Anthropic API (OAuth auth)
+ * @param {string} accessToken - OAuth access token
+ * @returns {Promise<Object>} { models: Array, error: string|null }
+ */
+const fetchAnthropicModelsOAuth = async (accessToken) => {
+  if (!accessToken) return { models: null, error: 'No access token provided' };
+  
+  const modelsUrl = 'https://api.anthropic.com/v1/models';
+  
+  const headers = {
+    'Authorization': `Bearer ${accessToken}`,
+    'anthropic-version': '2023-06-01',
+    'anthropic-beta': 'oauth-2025-04-20'
+  };
+  
+  try {
+    const response = await makeRequest(modelsUrl, { method: 'GET', headers, timeout: 15000 });
+    if (response.data && Array.isArray(response.data)) {
+      const models = response.data.map(m => m.id).filter(Boolean);
+      if (models.length > 0) return { models, error: null };
+    }
+    return { models: null, error: 'API returned empty or invalid response' };
+  } catch (error) {
+    return { models: null, error: error.message };
+  }
+};
+
+/**
+ * Fetch available models from Google Gemini API
+ * @param {string} apiKey - API key
+ * @returns {Promise<Array|null>} Array of model IDs or null on error
+ */
+const fetchGeminiModels = async (apiKey) => {
+  if (!apiKey) return null;
+  
+  const url = `https://generativelanguage.googleapis.com/v1/models?key=${apiKey}`;
+  
+  try {
+    const response = await makeRequest(url, { method: 'GET', timeout: 10000 });
+    if (response.models && Array.isArray(response.models)) {
+      return response.models
+        .filter(m => m.supportedGenerationMethods?.includes('generateContent'))
+        .map(m => m.name.replace('models/', ''))
+        .filter(Boolean);
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+};
+
+/**
+ * Fetch available models from OpenAI-compatible API
+ * @param {string} endpoint - API endpoint base URL
+ * @param {string} apiKey - API key or OAuth token
+ * @returns {Promise<Array|null>} Array of model IDs from API, null if unavailable
+ */
+const fetchOpenAIModels = async (endpoint, apiKey) => {
+  if (!endpoint) return null;
+  
+  const url = `${endpoint}/models`;
+  
+  const headers = {
+    'Content-Type': 'application/json'
+  };
+  
+  if (apiKey) {
+    headers['Authorization'] = `Bearer ${apiKey}`;
+  }
+  
+  try {
+    const response = await makeRequest(url, { method: 'GET', headers, timeout: 10000 });
+    if (response.data && Array.isArray(response.data)) {
+      const chatModels = response.data
+        .map(m => m.id)
+        .filter(id => id && (
+          id.includes('gpt') || 
+          id.includes('o1') || 
+          id.includes('o3') ||
+          id.includes('claude') ||
+          id.includes('gemini')
+        ))
+        .filter(id => 
+          !id.includes('embedding') &&
+          !id.includes('whisper') &&
+          !id.includes('tts') &&
+          !id.includes('dall-e')
+        );
+      
+      return chatModels.length > 0 ? chatModels : null;
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+};
+
+/**
+ * Fetch available models for OAuth-authenticated providers
+ * @param {string} providerId - Provider ID
+ * @param {string} accessToken - OAuth access token
+ * @returns {Promise<Array|null>} Array of model IDs from API, null if unavailable
+ */
+const fetchModelsWithOAuth = async (providerId, accessToken) => {
+  if (!accessToken) return null;
+  
+  try {
+    switch (providerId) {
+      case 'anthropic':
+        return await fetchAnthropicModelsOAuth(accessToken);
+      
+      case 'openai': {
+        const openaiModels = await fetchOpenAIModels('https://api.openai.com/v1', accessToken);
+        if (openaiModels && openaiModels.length > 0) {
+          return openaiModels;
+        }
+        
+        // Try ChatGPT backend API (for Plus/Pro plans)
+        try {
+          const chatgptUrl = 'https://chatgpt.com/backend-api/models';
+          const chatgptHeaders = {
+            'Authorization': `Bearer ${accessToken}`,
+            'Content-Type': 'application/json'
+          };
+          const chatgptResponse = await makeRequest(chatgptUrl, { 
+            method: 'GET', 
+            headers: chatgptHeaders, 
+            timeout: 10000 
+          });
+          if (chatgptResponse.models && Array.isArray(chatgptResponse.models)) {
+            return chatgptResponse.models
+              .map(m => m.slug || m.id || m.name)
+              .filter(Boolean);
+          }
+        } catch (e) {
+          if (process.env.HQX_DEBUG) {
+            console.error('[DEBUG] ChatGPT backend error:', e.message);
+          }
+        }
+        
+        return null;
+      }
+      
+      case 'gemini': {
+        try {
+          const geminiUrl = 'https://generativelanguage.googleapis.com/v1/models';
+          const geminiHeaders = {
+            'Authorization': `Bearer ${accessToken}`
+          };
+          const geminiResponse = await makeRequest(geminiUrl, { 
+            method: 'GET', 
+            headers: geminiHeaders, 
+            timeout: 15000 
+          });
+          if (geminiResponse.models && Array.isArray(geminiResponse.models)) {
+            const models = geminiResponse.models
+              .filter(m => m.supportedGenerationMethods?.includes('generateContent'))
+              .map(m => m.name.replace('models/', ''))
+              .filter(Boolean);
+            if (models.length > 0) return models;
+          }
+        } catch (e) {
+          if (process.env.HQX_DEBUG) {
+            console.error('[DEBUG] Gemini models API error:', e.message);
+          }
+        }
+        
+        return null;
+      }
+      
+      case 'qwen': {
+        try {
+          const qwenUrl = 'https://dashscope.aliyuncs.com/api/v1/models';
+          const qwenHeaders = {
+            'Authorization': `Bearer ${accessToken}`,
+            'Content-Type': 'application/json'
+          };
+          const qwenResponse = await makeRequest(qwenUrl, { 
+            method: 'GET', 
+            headers: qwenHeaders, 
+            timeout: 10000 
+          });
+          if (qwenResponse.data && Array.isArray(qwenResponse.data)) {
+            return qwenResponse.data
+              .map(m => m.id || m.model_id)
+              .filter(Boolean);
+          }
+        } catch (e) {
+          // Qwen API may not support model listing
+        }
+        return null;
+      }
+      
+      case 'iflow': {
+        try {
+          const iflowUrl = 'https://apis.iflow.cn/v1/models';
+          const iflowHeaders = {
+            'Authorization': `Bearer ${accessToken}`,
+            'Content-Type': 'application/json'
+          };
+          const iflowResponse = await makeRequest(iflowUrl, { 
+            method: 'GET', 
+            headers: iflowHeaders, 
+            timeout: 10000 
+          });
+          if (iflowResponse.data && Array.isArray(iflowResponse.data)) {
+            return iflowResponse.data
+              .map(m => m.id)
+              .filter(Boolean);
+          }
+        } catch (e) {
+          // iFlow API may not support model listing
+        }
+        return null;
+      }
+      
+      default:
+        return null;
+    }
+  } catch (error) {
+    return null;
+  }
+};
+
+/**
+ * Fetch models via local CLIProxyAPI proxy
+ * @returns {Promise<Array|null>} Array of model IDs or null
+ */
+const fetchModelsViaProxy = async (proxyPort = 8317) => {
+  const url = `http://127.0.0.1:${proxyPort}/v1/models`;
+  
+  const headers = {
+    'Authorization': 'Bearer hqx-local-key'
+  };
+  
+  try {
+    const response = await makeRequest(url, { method: 'GET', headers, timeout: 10000 });
+    if (response.data && Array.isArray(response.data)) {
+      return response.data.map(m => m.id || m).filter(Boolean);
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+};
+
+module.exports = {
+  fetchAnthropicModels,
+  fetchAnthropicModelsOAuth,
+  fetchGeminiModels,
+  fetchOpenAIModels,
+  fetchModelsWithOAuth,
+  fetchModelsViaProxy,
+};