Regulatory Compliance & Audit

import { BBMCPClient } from '@quietstack/bb-mcp';

class CompliantTradingAgent {
  constructor(apiKey, agentId) {
    this.bbmcp = new BBMCPClient({ apiKey });
    this.agentId = agentId;
  }

  async executeTrade(orderRequest) {
    // Create comprehensive context for audit trail
    const context = {
      agent_id: this.agentId,
      context_data: {
        task: 'algorithmic_trading_decision',
        order_type: orderRequest.type,
        symbol: orderRequest.symbol,
        quantity: orderRequest.quantity,
        decision_factors: {
          market_data: this.getCurrentMarketData(orderRequest.symbol),
          risk_metrics: this.calculateRiskMetrics(orderRequest),
          model_prediction: this.getModelPrediction(orderRequest),
          compliance_checks: this.runComplianceChecks(orderRequest)
        },
        decision: 'approved', // or 'rejected'
        decision_confidence: 0.92,
        risk_score: 0.15
      },
      metadata: {
        regulation: 'MiFID_II',
        trader_id: orderRequest.traderId,
        desk: orderRequest.desk,
        strategy: 'momentum_v2.1',
        model_version: '1.3.2',
        timestamp: new Date().toISOString(),
        session_id: this.sessionId
      }
    };

    // Log decision to blockchain BEFORE executing trade
    const verification = await this.bbmcp.contexts.create(context);
    
    if (context.context_data.decision === 'approved') {
      const tradeResult = await this.executeOrder(orderRequest);
      
      // Log execution results
      await this.bbmcp.contexts.create({
        agent_id: this.agentId,
        context_data: {
          task: 'trade_execution',
          original_decision_hash: verification.context_hash,
          execution_price: tradeResult.price,
          filled_quantity: tradeResult.quantity,
          execution_time: tradeResult.timestamp,
          slippage: this.calculateSlippage(orderRequest, tradeResult)
        },
        metadata: {
          ...context.metadata,
          execution_venue: tradeResult.venue,
          order_id: tradeResult.orderId
        }
      });

      return {
        ...tradeResult,
        compliance_hash: verification.transaction_hash,
        verified: true
      };
    }

    return { 
      rejected: true, 
      reason: context.context_data.decision_factors.compliance_checks.reason,
      compliance_hash: verification.transaction_hash
    };
  }

  // Generate compliance report for regulators
  async generateAuditReport(startDate, endDate) {
    const contexts = await this.bbmcp.contexts.list({
      agent_id: this.agentId,
      from_date: startDate,
      to_date: endDate,
      limit: 1000
    });

    return {
      period: { startDate, endDate },
      total_decisions: contexts.items.length,
      decisions_verified: contexts.items.filter(c => c.status === 'confirmed').length,
      average_confidence: this.calculateAverageConfidence(contexts.items),
      blockchain_hashes: contexts.items.map(c => c.transaction_hash),
      audit_trail_url: `https://polygonscan.com/tx/${contexts.items[0]?.transaction_hash}`
    };
  }
}

class HIPAACompliantDiagnosticAgent {
  constructor(apiKey, agentId, facilityId) {
    this.bbmcp = new BBMCPClient({ apiKey });
    this.agentId = agentId;
    this.facilityId = facilityId;
  }

  async analyzeImage(imageData, patientId, physicianId) {
    // Create de-identified context for blockchain logging
    const anonymizedPatientId = this.hashPatientId(patientId);
    
    const context = {
      agent_id: this.agentId,
      context_data: {
        task: 'medical_image_analysis',
        image_characteristics: {
          type: imageData.type, // 'xray', 'mri', 'ct'
          body_part: imageData.bodyPart,
          image_hash: this.computeImageHash(imageData.buffer),
          acquisition_parameters: imageData.parameters
        },
        ai_analysis: {
          model: 'diagnostic_ai_v2.1',
          findings: this.runAnalysis(imageData),
          confidence_scores: this.getConfidenceScores(),
          differential_diagnosis: this.getDifferentialDiagnosis(),
          recommended_followup: this.getRecommendations()
        },
        quality_metrics: {
          image_quality_score: this.assessImageQuality(imageData),
          model_certainty: this.getModelCertainty(),
          flag_for_review: this.shouldFlagForReview()
        }
      },
      metadata: {
        regulation_compliance: ['HIPAA', 'FDA_510k'],
        facility_id: this.facilityId,
        physician_id: physicianId,
        anonymized_patient_id: anonymizedPatientId,
        image_acquisition_date: imageData.acquisitionDate,
        analysis_timestamp: new Date().toISOString(),
        model_version: '2.1.3',
        calibration_date: this.getLastCalibrationDate()
      }
    };

    // Verify context on blockchain
    const verification = await this.bbmcp.contexts.create(context);

    return {
      findings: context.context_data.ai_analysis.findings,
      confidence: context.context_data.ai_analysis.confidence_scores,
      recommendations: context.context_data.ai_analysis.recommended_followup,
      compliance_record: {
        blockchain_hash: verification.transaction_hash,
        verification_status: verification.status,
        audit_trail_id: verification.context_id
      }
    };
  }

  // Generate FDA compliance report
  async generateFDAReport(startDate, endDate) {
    const contexts = await this.bbmcp.contexts.list({
      agent_id: this.agentId,
      from_date: startDate,
      to_date: endDate
    });

    const analyses = contexts.items.filter(
      c => c.context_data.task === 'medical_image_analysis'
    );

    return {
      report_period: { startDate, endDate },
      total_analyses: analyses.length,
      model_performance: {
        average_confidence: this.calculateAverageConfidence(analyses),
        flagged_for_review: analyses.filter(
          a => a.context_data.quality_metrics.flag_for_review
        ).length,
        model_stability: this.assessModelStability(analyses)
      },
      compliance_verification: {
        blockchain_verified: analyses.filter(a => a.status === 'confirmed').length,
        audit_trail_complete: true,
        data_integrity_verified: true
      },
      blockchain_audit_links: analyses.map(a => 
        `https://polygonscan.com/tx/${a.transaction_hash}`
      )
    };
  }
}

class GDPRCompliantAIAgent {
  constructor(apiKey, agentId) {
    this.bbmcp = new BBMCPClient({ apiKey });
    this.agentId = agentId;
  }

  async processPersonalData(request) {
    // Validate lawful basis before processing
    const lawfulBasis = await this.validateLawfulBasis(request);
    if (!lawfulBasis.valid) {
      throw new Error(`No lawful basis: ${lawfulBasis.reason}`);
    }

    const context = {
      agent_id: this.agentId,
      context_data: {
        task: 'gdpr_compliant_processing',
        processing_purpose: request.purpose,
        lawful_basis: {
          article: lawfulBasis.article, // e.g., "6.1.a" (consent)
          description: lawfulBasis.description,
          evidence: lawfulBasis.evidence_id
        },
        data_categories: this.classifyDataCategories(request.data),
        processing_operations: [
          'collection',
          'analysis', 
          'automated_decision_making'
        ],
        data_minimization: {
          fields_processed: this.getMinimalFields(request),
          fields_excluded: this.getExcludedFields(request),
          retention_period: this.getRetentionPeriod(request.purpose)
        },
        subject_rights: {
          consent_status: request.consent?.status,
          opt_out_mechanism: 'available',
          data_portability: 'supported',
          right_to_rectification: 'supported'
        }
      },
      metadata: {
        regulation: 'GDPR',
        controller: process.env.DATA_CONTROLLER_ID,
        processor: this.agentId,
        processing_timestamp: new Date().toISOString(),
        data_subject_id: this.hashDataSubjectId(request.subjectId),
        consent_version: request.consent?.version,
        privacy_policy_version: process.env.PRIVACY_POLICY_VERSION
      }
    };

    // Log processing decision to blockchain
    const verification = await this.bbmcp.contexts.create(context);

    // Perform the actual processing
    const result = await this.executeProcessing(request);

    // Log completion
    await this.bbmcp.contexts.create({
      agent_id: this.agentId,
      context_data: {
        task: 'processing_completion',
        original_decision_hash: verification.context_hash,
        processing_successful: true,
        output_classification: this.classifyOutput(result),
        automated_decision: result.isAutomatedDecision || false
      },
      metadata: {
        ...context.metadata,
        completion_timestamp: new Date().toISOString()
      }
    });

    return {
      ...result,
      gdpr_compliance: {
        blockchain_record: verification.transaction_hash,
        lawful_basis: context.context_data.lawful_basis,
        subject_rights_info: 'Available at /privacy/rights',
        audit_trail_id: verification.context_id
      }
    };
  }

  // Generate Article 30 Record of Processing Activities
  async generateArticle30Report() {
    const contexts = await this.bbmcp.contexts.list({
      agent_id: this.agentId,
      limit: 10000 // Get all processing activities
    });

    const processingActivities = contexts.items.filter(
      c => c.context_data.task === 'gdpr_compliant_processing'
    );

    return {
      controller: process.env.DATA_CONTROLLER_NAME,
      report_date: new Date().toISOString(),
      processing_activities: processingActivities.map(activity => ({
        purpose: activity.context_data.processing_purpose,
        lawful_basis: activity.context_data.lawful_basis.article,
        data_categories: activity.context_data.data_categories,
        retention_period: activity.context_data.data_minimization.retention_period,
        security_measures: 'Blockchain verification, encryption at rest',
        blockchain_record: activity.transaction_hash,
        processing_date: activity.timestamp
      })),
      audit_verification: {
        total_activities: processingActivities.length,
        blockchain_verified: processingActivities.filter(a => a.status === 'confirmed').length,
        compliance_rate: '100%'
      }
    };
  }
}