hedgequantx 2.6.163 → 2.7.0

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

@@ -1,333 +0,0 @@
-/**
- * @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,
-};

package/src/services/ai/client.js

@@ -1,343 +0,0 @@
-/**
- * AI Client - Makes real API calls to AI providers
- * 
- * STRICT RULE: No mock responses. Real API calls only.
- * If API fails → return null, not fake data.
- * 
- * Supports two modes:
- * 1. Direct API calls (with API keys)
- * 2. Proxy mode (via CLIProxyAPI for subscription accounts)
- */
-
-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
- * @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();
-  });
-};
-
-/**
- * Call OpenAI-compatible API
- * Works with: OpenAI, Groq, Together, DeepSeek, Mistral, xAI, etc.
- * @param {Object} agent - Agent configuration
- * @param {string} prompt - User prompt
- * @param {string} systemPrompt - System prompt
- * @param {Object} options - Optional settings { maxTokens, temperature, timeout }
- * @returns {Promise<string|null>} Response text or null on error
- */
-const callOpenAICompatible = async (agent, prompt, systemPrompt, options = {}) => {
-  const provider = getProvider(agent.providerId);
-  if (!provider) return null;
-  
-  const endpoint = agent.credentials?.endpoint || provider.endpoint;
-  const apiKey = agent.credentials?.apiKey;
-  const model = agent.model || provider.defaultModel;
-  
-  if (!apiKey && provider.category !== 'local') {
-    return null;
-  }
-  
-  const url = `${endpoint}/chat/completions`;
-  
-  const headers = {
-    'Content-Type': 'application/json'
-  };
-  
-  if (apiKey) {
-    headers['Authorization'] = `Bearer ${apiKey}`;
-  }
-  
-  // OpenRouter requires additional headers
-  if (agent.providerId === 'openrouter') {
-    headers['HTTP-Referer'] = 'https://hedgequantx.com';
-    headers['X-Title'] = 'HQX-CLI';
-  }
-  
-  const body = {
-    model,
-    messages: [
-      { role: 'system', content: systemPrompt },
-      { role: 'user', content: prompt }
-    ],
-    temperature: options.temperature || 0.3
-  };
-  
-  try {
-    const timeout = options.timeout || 30000;
-    const response = await makeRequest(url, { headers, body, timeout });
-    return response.choices?.[0]?.message?.content || null;
-  } catch (error) {
-    return null;
-  }
-};
-
-/**
- * Get valid OAuth token (refresh if needed)
- * @param {Object} credentials - Agent credentials with oauth data
- * @returns {Promise<string|null>} Valid access token or null
- */
-const getValidOAuthToken = async (credentials) => {
-  if (!credentials?.oauth) return null;
-  
-  const oauthAnthropic = require('./oauth-anthropic');
-  const validToken = await oauthAnthropic.getValidToken(credentials.oauth);
-  
-  if (!validToken) return null;
-  
-  // If token was refreshed, we should update storage (handled by caller)
-  if (validToken.refreshed) {
-    credentials.oauth.access = validToken.access;
-    credentials.oauth.refresh = validToken.refresh;
-    credentials.oauth.expires = validToken.expires;
-  }
-  
-  return validToken.access;
-};
-
-/**
- * Call Anthropic Claude API
- * Supports both API key and OAuth authentication
- * @param {Object} agent - Agent configuration
- * @param {string} prompt - User prompt
- * @param {string} systemPrompt - System prompt
- * @param {Object} options - Optional settings { maxTokens, temperature, timeout }
- * @returns {Promise<string|null>} Response text or null on error
- */
-const callAnthropic = async (agent, prompt, systemPrompt, options = {}) => {
-  const provider = getProvider('anthropic');
-  if (!provider) return null;
-  
-  const model = agent.model || provider.defaultModel;
-  const url = `${provider.endpoint}/messages`;
-  
-  // Determine authentication method
-  const isOAuth = agent.credentials?.oauth?.refresh;
-  let headers = {
-    'Content-Type': 'application/json',
-    'anthropic-version': '2023-06-01'
-  };
-  
-  if (isOAuth) {
-    // OAuth Bearer token authentication
-    const accessToken = await getValidOAuthToken(agent.credentials);
-    if (!accessToken) return null;
-    
-    headers['Authorization'] = `Bearer ${accessToken}`;
-    headers['anthropic-beta'] = 'oauth-2025-04-20,interleaved-thinking-2025-05-14';
-  } else {
-    // Standard API key authentication
-    const apiKey = agent.credentials?.apiKey;
-    if (!apiKey) return null;
-    
-    headers['x-api-key'] = apiKey;
-  }
-  
-  const body = {
-    model,
-    system: systemPrompt,
-    messages: [
-      { role: 'user', content: prompt }
-    ]
-  };
-  
-  try {
-    const timeout = options.timeout || 30000;
-    const response = await makeRequest(url, { headers, body, timeout });
-    return response.content?.[0]?.text || null;
-  } catch (error) {
-    return null;
-  }
-};
-
-/**
- * Call Google Gemini API
- * @param {Object} agent - Agent configuration
- * @param {string} prompt - User prompt
- * @param {string} systemPrompt - System prompt
- * @returns {Promise<string|null>} Response text or null on error
- */
-const callGemini = async (agent, prompt, systemPrompt, options = {}) => {
-  const provider = getProvider('gemini');
-  if (!provider) return null;
-  
-  const apiKey = agent.credentials?.apiKey;
-  const model = agent.model || provider.defaultModel;
-  
-  if (!apiKey) return null;
-  
-  const url = `${provider.endpoint}/models/${model}:generateContent?key=${apiKey}`;
-  
-  const headers = {
-    'Content-Type': 'application/json'
-  };
-  
-  const body = {
-    contents: [
-      { role: 'user', parts: [{ text: `${systemPrompt}\n\n${prompt}` }] }
-    ],
-    generationConfig: {
-      temperature: 0.3
-    }
-  };
-  
-  try {
-    const timeout = options.timeout || 60000;
-    const response = await makeRequest(url, { headers, body, timeout });
-    return response.candidates?.[0]?.content?.parts?.[0]?.text || null;
-  } catch (error) {
-    return null;
-  }
-};
-
-/**
- * Call AI via local CLIProxyAPI proxy
- * Used for subscription accounts (ChatGPT Plus, Claude Pro, etc.)
- * @param {Object} agent - Agent configuration
- * @param {string} prompt - User prompt
- * @param {string} systemPrompt - System prompt
- * @returns {Promise<string|null>} Response text or null on error
- */
-const callViaProxy = async (agent, prompt, systemPrompt, options = {}) => {
-  const proxyPort = agent.credentials?.proxyPort || 8317;
-  const model = agent.model;
-  
-  if (!model) return null;
-  
-  const url = `http://127.0.0.1:${proxyPort}/v1/chat/completions`;
-  
-  const headers = {
-    'Content-Type': 'application/json',
-    'Authorization': 'Bearer hqx-local-key'
-  };
-  
-  const body = {
-    model,
-    messages: [
-      { role: 'system', content: systemPrompt },
-      { role: 'user', content: prompt }
-    ],
-    temperature: 0.3
-  };
-  
-  try {
-    const timeout = options.timeout || 60000;
-    const response = await makeRequest(url, { headers, body, timeout });
-    return response.choices?.[0]?.message?.content || null;
-  } catch (error) {
-    return null;
-  }
-};
-
-/**
- * Call AI provider based on agent configuration
- * @param {Object} agent - Agent with providerId and credentials
- * @param {string} prompt - User prompt
- * @param {string} systemPrompt - System prompt
- * @param {Object} options - Optional settings { maxTokens, temperature, timeout }
- * @returns {Promise<string|null>} AI response or null on error
- */
-const callAI = async (agent, prompt, systemPrompt = '', options = {}) => {
-  if (!agent || !agent.providerId) return null;
-  
-  // Default timeout 60s for code generation
-  const opts = { timeout: 60000, ...options };
-  
-  // Check if using proxy mode (subscription accounts)
-  if (agent.credentials?.useProxy) {
-    return callViaProxy(agent, prompt, systemPrompt, opts);
-  }
-  
-  switch (agent.providerId) {
-    case 'anthropic':
-      return callAnthropic(agent, prompt, systemPrompt, opts);
-    
-    case 'gemini':
-      return callGemini(agent, prompt, systemPrompt, opts);
-    
-    // All OpenAI-compatible APIs
-    case 'openai':
-    case 'openrouter':
-    case 'deepseek':
-    case 'groq':
-    case 'xai':
-    case 'mistral':
-    case 'perplexity':
-    case 'together':
-    case 'qwen':
-    case 'moonshot':
-    case 'yi':
-    case 'zhipu':
-    case 'baichuan':
-    case 'ollama':
-    case 'lmstudio':
-    case 'custom':
-      return callOpenAICompatible(agent, prompt, systemPrompt, opts);
-    
-    default:
-      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,
-  callViaProxy,
-  analyzeTrading,
-  analyzePerformance,
-  getMarketAdvice,
-  callOpenAICompatible,
-  callAnthropic,
-  callGemini,
-  fetchAnthropicModels,
-  fetchAnthropicModelsOAuth,
-  fetchGeminiModels,
-  fetchOpenAIModels,
-  fetchModelsWithOAuth,
-  fetchModelsViaProxy,
-  getValidOAuthToken
-};