hedgequantx 2.6.161 → 2.6.162

package/src/services/ai/client.js

@@ -12,6 +12,8 @@
 const https = require('https');
 const http = require('http');
 const { getProvider } = require('./providers');
+const { analyzeTrading: analyzeTradingImpl, analyzePerformance: analyzePerformanceImpl, getMarketAdvice: getMarketAdviceImpl } = require('./client-analysis');
+const { fetchAnthropicModels, fetchAnthropicModelsOAuth, fetchGeminiModels, fetchOpenAIModels, fetchModelsWithOAuth, fetchModelsViaProxy } = require('./client-models');
 
 /**
  * Make HTTP request to AI provider
@@ -317,495 +319,10 @@ const callAI = async (agent, prompt, systemPrompt = '', options = {}) => {
   }
 };
 
-/**
- * Analyze trading data with AI
- * @param {Object} agent - AI agent
- * @param {Object} data - Trading data from APIs
- * @returns {Promise<Object|null>} Analysis result or null
- */
-const analyzeTrading = async (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;
-    
-    // Try to parse JSON from response
-    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
- * Called periodically to help the strategy improve
- * 
- * @param {Object} agent - AI agent
- * @param {Object} performanceData - Strategy performance data
- * @returns {Promise<Object|null>} Optimization suggestions
- */
-const analyzePerformance = async (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;
-    
-    // Parse JSON from response
-    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 {Object} agent - AI agent
- * @param {Object} marketData - Current market data
- * @returns {Promise<Object|null>} Trading advice
- */
-const getMarketAdvice = async (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;
-  }
-};
-
-/**
- * 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
- * 
- * Data source: https://api.anthropic.com/v1/models (GET)
- */
-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 }
- * 
- * Data source: https://api.anthropic.com/v1/models (GET with Bearer token)
- * NO HARDCODED FALLBACK - models must come from API only
- */
-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
- * 
- * Data source: https://generativelanguage.googleapis.com/v1/models (GET)
- */
-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)) {
-      // Filter only generative models and extract the model name
-      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
- * @param {string} apiKey - API key
- * @returns {Promise<Array|null>} Array of model IDs or null on error
- * 
- * Data source: {endpoint}/models (GET)
- */
-/**
- * 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
- * 
- * Data source: {endpoint}/models (GET)
- */
-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)) {
-      // Return models from API - filter to chat models only
-      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
- * Uses multiple API endpoints to discover available models
- * 
- * @param {string} providerId - Provider ID (anthropic, openai, gemini, etc.)
- * @param {string} accessToken - OAuth access token
- * @returns {Promise<Array|null>} Array of model IDs from API, null if unavailable
- * 
- * Data sources:
- * - OpenAI: https://api.openai.com/v1/models (GET)
- * - Anthropic: https://api.anthropic.com/v1/models (GET)
- * - Gemini: https://generativelanguage.googleapis.com/v1/models (GET)
- */
-const fetchModelsWithOAuth = async (providerId, accessToken) => {
-  if (!accessToken) return null;
-  
-  try {
-    switch (providerId) {
-      case 'anthropic':
-        return await fetchAnthropicModelsOAuth(accessToken);
-      
-      case 'openai': {
-        // Try OpenAI /v1/models endpoint with OAuth token
-        // NO HARDCODED FALLBACK - models must come from API only
-        const openaiModels = await fetchOpenAIModels('https://api.openai.com/v1', accessToken);
-        if (openaiModels && openaiModels.length > 0) {
-          return openaiModels;
-        }
-        
-        // Try alternative: 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': {
-        // Gemini OAuth - fetch from Generative Language API
-        // NO HARDCODED FALLBACK - models must come from API only
-        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': {
-        // Qwen - try to fetch models from Alibaba Cloud API
-        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': {
-        // iFlow - fetch models from iFlow API
-        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;
-  }
-};
+// Wrapper functions for analysis (pass callAI to implementation)
+const analyzeTrading = (agent, data) => analyzeTradingImpl(callAI, agent, data);
+const analyzePerformance = (agent, performanceData) => analyzePerformanceImpl(callAI, agent, performanceData);
+const getMarketAdvice = (agent, marketData) => getMarketAdviceImpl(callAI, agent, marketData);
 
 module.exports = {
   callAI,