hedgequantx 2.7.99 → 2.8.0

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

@@ -0,0 +1,309 @@
+/**
+ * AI Supervision Engine - Main Entry Point
+ * 
+ * Orchestrates multi-agent AI supervision for trading signals.
+ * Sends signals to all active agents in parallel and calculates
+ * weighted consensus for final decision.
+ */
+
+const { getFullDirective } = require('./directive');
+const { buildMarketContext, formatContextForPrompt } = require('./context');
+const { parseAgentResponse } = require('./parser');
+const { calculateConsensus, isApproved, applyOptimizations } = require('./consensus');
+const { runPreflightCheck, formatPreflightResults, getPreflightSummary } = require('./health');
+const cliproxy = require('../cliproxy');
+
+/**
+ * SupervisionEngine class - manages multi-agent supervision
+ */
+class SupervisionEngine {
+  constructor(config = {}) {
+    this.agents = config.agents || [];
+    this.timeout = config.timeout || 30000;
+    this.minAgents = config.minAgents || 1;
+    this.directive = getFullDirective();
+    this.activeAgents = new Map();
+    this.rateLimitedAgents = new Set();
+    
+    // Initialize active agents
+    for (const agent of this.agents) {
+      if (agent.active) {
+        this.activeAgents.set(agent.id, agent);
+      }
+    }
+  }
+
+  /**
+   * Get count of active (non-rate-limited) agents
+   */
+  getActiveCount() {
+    return this.activeAgents.size - this.rateLimitedAgents.size;
+  }
+
+  /**
+   * Check if supervision is available
+   */
+  isAvailable() {
+    return this.getActiveCount() >= this.minAgents;
+  }
+
+  /**
+   * Mark agent as rate limited
+   */
+  markRateLimited(agentId) {
+    this.rateLimitedAgents.add(agentId);
+  }
+
+  /**
+   * Reset rate limited agents (call periodically)
+   */
+  resetRateLimits() {
+    this.rateLimitedAgents.clear();
+  }
+
+  /**
+   * Build prompt for AI agent
+   */
+  buildPrompt(context) {
+    const contextStr = formatContextForPrompt(context);
+    return `${this.directive}\n\n${contextStr}\n\nAnalyze this signal and respond with JSON only.`;
+  }
+
+  /**
+   * Query a single agent
+   */
+  async queryAgent(agent, prompt) {
+    const startTime = Date.now();
+    
+    try {
+      let response;
+      
+      if (agent.connectionType === 'cliproxy') {
+        // Use CLIProxy API
+        response = await cliproxy.chat(agent.provider, agent.modelId, prompt, this.timeout);
+      } else if (agent.connectionType === 'apikey' && agent.apiKey) {
+        // Direct API call (implement per provider)
+        response = await this.callDirectAPI(agent, prompt);
+      } else {
+        throw new Error('Invalid agent configuration');
+      }
+
+      const latency = Date.now() - startTime;
+      
+      if (!response.success) {
+        // Check for rate limit
+        if (response.error?.includes('rate') || response.error?.includes('limit')) {
+          this.markRateLimited(agent.id);
+        }
+        return { success: false, error: response.error, latency };
+      }
+
+      const parsed = parseAgentResponse(response.content || response.text);
+      
+      return {
+        success: true,
+        response: parsed,
+        latency,
+        raw: response
+      };
+
+    } catch (error) {
+      const latency = Date.now() - startTime;
+      
+      // Check for rate limit errors
+      if (error.message?.includes('429') || error.message?.includes('rate')) {
+        this.markRateLimited(agent.id);
+      }
+      
+      return {
+        success: false,
+        error: error.message,
+        latency
+      };
+    }
+  }
+
+  /**
+   * Direct API call for API key connections
+   */
+  async callDirectAPI(agent, prompt) {
+    // This would be implemented per provider
+    // For now, return error to use CLIProxy instead
+    return {
+      success: false,
+      error: 'Direct API not implemented - use CLIProxy'
+    };
+  }
+
+  /**
+   * Query all agents in parallel
+   */
+  async queryAllAgents(prompt) {
+    const availableAgents = Array.from(this.activeAgents.values())
+      .filter(agent => !this.rateLimitedAgents.has(agent.id));
+
+    if (availableAgents.length === 0) {
+      return [];
+    }
+
+    // Query all agents in parallel with timeout
+    const queries = availableAgents.map(agent => 
+      Promise.race([
+        this.queryAgent(agent, prompt),
+        new Promise((_, reject) => 
+          setTimeout(() => reject(new Error('Timeout')), this.timeout)
+        )
+      ]).then(result => ({
+        agentId: agent.id,
+        agentName: agent.name,
+        weight: agent.weight || 100,
+        ...result
+      })).catch(error => ({
+        agentId: agent.id,
+        agentName: agent.name,
+        weight: agent.weight || 100,
+        success: false,
+        error: error.message
+      }))
+    );
+
+    return Promise.all(queries);
+  }
+
+  /**
+   * Main supervision method - analyze a signal
+   */
+  async supervise(params) {
+    const {
+      symbolId,
+      signal,
+      recentTicks = [],
+      recentSignals = [],
+      recentTrades = [],
+      domData = null,
+      position = null,
+      stats = {},
+      config = {}
+    } = params;
+
+    // Check availability
+    if (!this.isAvailable()) {
+      return {
+        success: false,
+        error: 'No agents available',
+        decision: 'approve',
+        reason: 'No AI supervision - passing through'
+      };
+    }
+
+    // Build context and prompt
+    const context = buildMarketContext({
+      symbolId,
+      signal,
+      recentTicks,
+      recentSignals,
+      recentTrades,
+      domData,
+      position,
+      stats,
+      config
+    });
+
+    const prompt = this.buildPrompt(context);
+
+    // Query all agents
+    const results = await this.queryAllAgents(prompt);
+
+    // Filter successful responses
+    const successfulResults = results.filter(r => r.success);
+
+    if (successfulResults.length === 0) {
+      return {
+        success: false,
+        error: 'All agents failed',
+        decision: 'approve',
+        reason: 'Agent errors - passing through',
+        agentResults: results
+      };
+    }
+
+    // Calculate consensus
+    const consensus = calculateConsensus(
+      successfulResults.map(r => ({
+        agentId: r.agentId,
+        response: r.response,
+        weight: r.weight
+      })),
+      { minAgents: this.minAgents }
+    );
+
+    // Apply optimizations if approved
+    const optimizedSignal = isApproved(consensus) 
+      ? applyOptimizations(signal, consensus)
+      : signal;
+
+    return {
+      success: true,
+      decision: consensus.decision,
+      confidence: consensus.confidence,
+      reason: consensus.reason,
+      optimizedSignal,
+      consensus,
+      agentResults: results,
+      context
+    };
+  }
+
+  /**
+   * Get engine status
+   */
+  getStatus() {
+    return {
+      totalAgents: this.agents.length,
+      activeAgents: this.activeAgents.size,
+      rateLimitedAgents: this.rateLimitedAgents.size,
+      availableAgents: this.getActiveCount(),
+      isAvailable: this.isAvailable(),
+      agents: Array.from(this.activeAgents.values()).map(a => ({
+        id: a.id,
+        name: a.name,
+        provider: a.provider,
+        weight: a.weight,
+        rateLimited: this.rateLimitedAgents.has(a.id)
+      }))
+    };
+  }
+
+  /**
+   * Run pre-flight check on all agents
+   * Verifies CLIProxy is running and all agents respond correctly
+   * @returns {Promise<Object>} Pre-flight results
+   */
+  async preflightCheck() {
+    const agents = Array.from(this.activeAgents.values());
+    return runPreflightCheck(agents);
+  }
+}
+
+/**
+ * Create supervision engine from config
+ */
+const createSupervisionEngine = (config) => {
+  return new SupervisionEngine(config);
+};
+
+module.exports = {
+  SupervisionEngine,
+  createSupervisionEngine,
+  // Re-export utilities
+  buildMarketContext,
+  formatContextForPrompt,
+  parseAgentResponse,
+  calculateConsensus,
+  isApproved,
+  applyOptimizations,
+  // Health check
+  runPreflightCheck,
+  formatPreflightResults,
+  getPreflightSummary
+};

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

@@ -0,0 +1,278 @@
+/**
+ * AI Response Parser
+ * 
+ * Parses responses from AI agents (JSON or text)
+ * and normalizes them to a standard format.
+ */
+
+/**
+ * Default response when parsing fails
+ */
+const DEFAULT_RESPONSE = {
+  decision: 'approve',
+  confidence: 50,
+  optimizations: null,
+  reason: 'Parse failed - defaulting to approve',
+  alerts: null,
+  parseSuccess: false
+};
+
+/**
+ * Extract JSON from a string that may contain markdown or extra text
+ */
+const extractJSON = (text) => {
+  if (!text || typeof text !== 'string') return null;
+
+  // Try direct parse first
+  try {
+    return JSON.parse(text.trim());
+  } catch (e) { /* continue */ }
+
+  // Try to find JSON in markdown code blocks
+  const codeBlockMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (codeBlockMatch) {
+    try {
+      return JSON.parse(codeBlockMatch[1].trim());
+    } catch (e) { /* continue */ }
+  }
+
+  // Try to find JSON object pattern
+  const jsonMatch = text.match(/\{[\s\S]*"decision"[\s\S]*\}/);
+  if (jsonMatch) {
+    try {
+      return JSON.parse(jsonMatch[0]);
+    } catch (e) { /* continue */ }
+  }
+
+  return null;
+};
+
+/**
+ * Validate and normalize the decision field
+ */
+const normalizeDecision = (decision) => {
+  if (!decision) return 'approve';
+  
+  const d = String(decision).toLowerCase().trim();
+  
+  if (d === 'approve' || d === 'yes' || d === 'accept' || d === 'go') return 'approve';
+  if (d === 'reject' || d === 'no' || d === 'deny' || d === 'stop') return 'reject';
+  if (d === 'modify' || d === 'adjust' || d === 'optimize') return 'modify';
+  
+  return 'approve';
+};
+
+/**
+ * Validate and normalize confidence score
+ */
+const normalizeConfidence = (confidence) => {
+  if (confidence === undefined || confidence === null) return 50;
+  
+  const c = Number(confidence);
+  if (isNaN(c)) return 50;
+  
+  // Handle percentage strings like "85%"
+  if (typeof confidence === 'string' && confidence.includes('%')) {
+    const parsed = parseFloat(confidence);
+    if (!isNaN(parsed)) return Math.min(100, Math.max(0, parsed));
+  }
+  
+  // Normalize to 0-100 range
+  if (c >= 0 && c <= 1) return Math.round(c * 100);
+  return Math.min(100, Math.max(0, Math.round(c)));
+};
+
+/**
+ * Validate and normalize optimizations
+ */
+const normalizeOptimizations = (opts, signal) => {
+  if (!opts) return null;
+  
+  const normalized = {
+    entry: null,
+    stopLoss: null,
+    takeProfit: null,
+    size: null,
+    timing: 'now'
+  };
+
+  // Entry price
+  if (opts.entry !== undefined && opts.entry !== null) {
+    const entry = Number(opts.entry);
+    if (!isNaN(entry) && entry > 0) normalized.entry = entry;
+  }
+
+  // Stop loss
+  if (opts.stopLoss !== undefined && opts.stopLoss !== null) {
+    const sl = Number(opts.stopLoss);
+    if (!isNaN(sl) && sl > 0) normalized.stopLoss = sl;
+  }
+
+  // Take profit
+  if (opts.takeProfit !== undefined && opts.takeProfit !== null) {
+    const tp = Number(opts.takeProfit);
+    if (!isNaN(tp) && tp > 0) normalized.takeProfit = tp;
+  }
+
+  // Size adjustment (-0.5 to +0.5)
+  if (opts.size !== undefined && opts.size !== null) {
+    const size = Number(opts.size);
+    if (!isNaN(size)) {
+      normalized.size = Math.min(0.5, Math.max(-0.5, size));
+    }
+  }
+
+  // Timing
+  if (opts.timing) {
+    const t = String(opts.timing).toLowerCase().trim();
+    if (t === 'now' || t === 'immediate') normalized.timing = 'now';
+    else if (t === 'wait' || t === 'delay') normalized.timing = 'wait';
+    else if (t === 'cancel' || t === 'abort') normalized.timing = 'cancel';
+    else normalized.timing = 'now';
+  }
+
+  return normalized;
+};
+
+/**
+ * Normalize reason string
+ */
+const normalizeReason = (reason) => {
+  if (!reason) return 'No reason provided';
+  
+  const r = String(reason).trim();
+  if (r.length > 100) return r.substring(0, 97) + '...';
+  return r;
+};
+
+/**
+ * Normalize alerts array
+ */
+const normalizeAlerts = (alerts) => {
+  if (!alerts) return null;
+  if (!Array.isArray(alerts)) {
+    if (typeof alerts === 'string') return [alerts];
+    return null;
+  }
+  return alerts.filter(a => a && typeof a === 'string').slice(0, 5);
+};
+
+/**
+ * Parse text response when JSON parsing fails
+ * Attempts to extract decision from natural language
+ */
+const parseTextResponse = (text, signal) => {
+  if (!text) return DEFAULT_RESPONSE;
+  
+  const lower = text.toLowerCase();
+  
+  // Determine decision from keywords
+  let decision = 'approve';
+  if (lower.includes('reject') || lower.includes('do not') || lower.includes("don't") || 
+      lower.includes('avoid') || lower.includes('skip') || lower.includes('no trade')) {
+    decision = 'reject';
+  } else if (lower.includes('modify') || lower.includes('adjust') || lower.includes('optimize') ||
+             lower.includes('tighten') || lower.includes('widen')) {
+    decision = 'modify';
+  }
+
+  // Try to extract confidence
+  let confidence = 60;
+  const confMatch = lower.match(/confidence[:\s]*(\d+)/i) || 
+                    lower.match(/(\d+)%?\s*confiden/i) ||
+                    lower.match(/score[:\s]*(\d+)/i);
+  if (confMatch) {
+    confidence = normalizeConfidence(confMatch[1]);
+  }
+
+  // Extract reason (first sentence or up to 100 chars)
+  let reason = text.split(/[.!?\n]/)[0]?.trim() || 'Parsed from text response';
+  reason = normalizeReason(reason);
+
+  return {
+    decision,
+    confidence,
+    optimizations: decision === 'modify' ? {
+      entry: signal?.entry || null,
+      stopLoss: signal?.stopLoss || null,
+      takeProfit: signal?.takeProfit || null,
+      size: null,
+      timing: 'now'
+    } : null,
+    reason,
+    alerts: null,
+    parseSuccess: false,
+    parsedFromText: true
+  };
+};
+
+/**
+ * Main parser function - parse AI response to standard format
+ */
+const parseAgentResponse = (response, signal = null) => {
+  // Handle empty response
+  if (!response) {
+    return { ...DEFAULT_RESPONSE, reason: 'Empty response from agent' };
+  }
+
+  // Handle response object with content field (common API format)
+  let text = response;
+  if (typeof response === 'object') {
+    if (response.content) text = response.content;
+    else if (response.text) text = response.text;
+    else if (response.message) text = response.message;
+    else text = JSON.stringify(response);
+  }
+
+  // Try to extract and parse JSON
+  const json = extractJSON(text);
+  
+  if (json && json.decision) {
+    // Successfully parsed JSON
+    return {
+      decision: normalizeDecision(json.decision),
+      confidence: normalizeConfidence(json.confidence),
+      optimizations: normalizeOptimizations(json.optimizations, signal),
+      reason: normalizeReason(json.reason),
+      alerts: normalizeAlerts(json.alerts),
+      parseSuccess: true
+    };
+  }
+
+  // Fallback to text parsing
+  return parseTextResponse(text, signal);
+};
+
+/**
+ * Validate a parsed response
+ */
+const validateResponse = (parsed) => {
+  const errors = [];
+  
+  if (!['approve', 'reject', 'modify'].includes(parsed.decision)) {
+    errors.push(`Invalid decision: ${parsed.decision}`);
+  }
+  
+  if (parsed.confidence < 0 || parsed.confidence > 100) {
+    errors.push(`Invalid confidence: ${parsed.confidence}`);
+  }
+  
+  if (parsed.decision === 'modify' && !parsed.optimizations) {
+    errors.push('Modify decision requires optimizations');
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+};
+
+module.exports = {
+  parseAgentResponse,
+  validateResponse,
+  extractJSON,
+  normalizeDecision,
+  normalizeConfidence,
+  normalizeOptimizations,
+  DEFAULT_RESPONSE
+};