AI Agents

func (a *AnalystAgent) Analyze(
    ctx context.Context,
    symbol string,
    role AnalystRole,
    signals []AnalystSignal,
) (*AnalystAnalysis, error) {
    analysis := &AnalystAnalysis{
        ID:         generateAnalystID(),
        Symbol:     symbol,
        Role:       role,
        Signals:    signals,
        AnalyzedAt: time.Now().UTC(),
    }
    
    // Calculate weighted score from signals
    weightedScore := 0.0
    totalWeight := 0.0
    bullishCount := 0
    bearishCount := 0
    
    for _, signal := range signals {
        weightedScore += signal.Value * signal.Weight
        totalWeight += signal.Weight
        
        if signal.Direction == "bullish" {
            bullishCount++
        } else if signal.Direction == "bearish" {
            bearishCount++
        }
    }
    
    analysis.Score = weightedScore / totalWeight
    analysis.Confidence = calculateConfidence(signals, analysis.Score)
    
    // Generate recommendation
    if bullishCount > bearishCount && analysis.Score > threshold {
        analysis.Recommendation = RecommendationBuy
    } else if bearishCount > bullishCount && analysis.Score < -threshold {
        analysis.Recommendation = RecommendationSell
    } else {
        analysis.Recommendation = RecommendationHold
    }
    
    return analysis, nil
}

type AnalystSignal struct {
    Name        string          // Signal name (e.g., "rsi", "macd")
    Value       float64         // Signal value (0.0-1.0 normalized)
    Weight      float64         // Signal importance (0.0-1.0)
    Direction   SignalDirection // "bullish", "bearish", "neutral"
    Description string          // Human-readable description
}

type RiskManagerRole string

const (
    RiskManagerRolePortfolio RiskManagerRole = "portfolio"
    RiskManagerRolePosition  RiskManagerRole = "position"
    RiskManagerRoleTrading   RiskManagerRole = "trading"
    RiskManagerRoleEmergency RiskManagerRole = "emergency"
)

func (a *RiskManagerAgent) AssessPortfolioRisk(
    _ context.Context,
    signals []RiskSignal,
) (*RiskAssessment, error) {
    assessment := &RiskAssessment{
        ID:              generateRiskID(),
        Role:            RiskManagerRolePortfolio,
        AssessedAt:      time.Now(),
        Reasons:         []string{},
        Recommendations: []string{},
    }
    
    score := calculateRiskScore(signals)
    assessment.Score = score
    assessment.Confidence = calculateRiskConfidence(signals)
    assessment.RiskLevel = determineRiskLevel(score)
    assessment.Action = determineAction(assessment.RiskLevel, score, a.config)
    
    // Generate reasons for high-risk signals
    for _, signal := range signals {
        if signal.Value > signal.Threshold {
            assessment.Reasons = append(assessment.Reasons, signal.Description)
        }
    }
    
    // Generate recommendations
    switch assessment.RiskLevel {
    case RiskLevelLow:
        assessment.Recommendations = append(assessment.Recommendations,
            "Portfolio risk is within acceptable limits")
    case RiskLevelMedium:
        assessment.Recommendations = append(assessment.Recommendations,
            "Consider reducing position sizes", "Monitor portfolio closely")
    case RiskLevelHigh:
        assessment.Recommendations = append(assessment.Recommendations,
            "Reduce exposure immediately", "Avoid new positions")
    case RiskLevelExtreme:
        assessment.Recommendations = append(assessment.Recommendations,
            "EMERGENCY: Close positions", "Halt all trading activity")
    }
    
    return assessment, nil
}

type RiskSignal struct {
    Name        string  // Signal name (e.g., "volatility", "drawdown")
    Value       float64 // Current value
    Weight      float64 // Importance weight (0.0-1.0)
    Threshold   float64 // Alert threshold
    Description string  // Human-readable description
}

func (a *RiskManagerAgent) CheckEmergencyConditions(
    _ context.Context,
    currentDrawdown float64,
    dailyLoss decimal.Decimal,
) (*RiskAssessment, error) {
    isEmergency := false
    
    // Check drawdown threshold
    if currentDrawdown >= a.config.EmergencyThreshold {
        assessment.Reasons = append(assessment.Reasons,
            fmt.Sprintf("Drawdown %.2f%% exceeds emergency threshold %.2f%%",
                currentDrawdown*100, a.config.EmergencyThreshold*100))
        isEmergency = true
    }
    
    // Check daily loss cap
    if dailyLoss.GreaterThanOrEqual(a.config.MaxDailyLoss) {
        assessment.Reasons = append(assessment.Reasons,
            fmt.Sprintf("Daily loss %s exceeds maximum %s",
                dailyLoss.String(), a.config.MaxDailyLoss.String()))
        isEmergency = true
    }
    
    if isEmergency {
        assessment.Action = RiskActionEmergency
        assessment.RiskLevel = RiskLevelExtreme
        assessment.Recommendations = append(assessment.Recommendations,
            "EMERGENCY: All positions should be closed immediately",
            "Halt all trading activity",
            "Review strategy before resuming")
    }
    
    return assessment, nil
}

func (l *AgentExecutionLoop) Execute(
    ctx context.Context,
    symbol string,
    marketContext MarketContext,
    portfolio PortfolioState,
) (*ExecutionLoopResult, error) {
    // Step 1: Analyst generates recommendation
    analysis, _ := l.runAnalysis(ctx, symbol, marketContext)
    
    // Step 2: LLM enriches context with tool calls
    if l.llmClient != nil && l.config.EnableToolCalls {
        toolCalls, toolResults, _ := l.runLLMWithTools(ctx, symbol, analysis, marketContext)
        result.ToolCallsMade = toolCalls
    }
    
    // Step 3: Trader makes decision
    tradingDecision, _ := l.traderAgent.MakeDecision(ctx, marketContext, portfolio)
    
    // Check if we should proceed (hold/wait)
    if tradingDecision.Action == ActionHold || tradingDecision.Action == ActionWait {
        result.Decision = ExecutionDecisionDefer
        return result, nil
    }
    
    // Step 4: Risk manager evaluates
    if l.config.RequireRiskApproval {
        riskAssessment, _ := l.riskManager.AssessTradingRisk(ctx, symbol, side, riskSignals)
        
        switch riskAssessment.Action {
        case risk.RiskActionBlock, risk.RiskActionEmergency:
            result.Decision = ExecutionDecisionReject
            return result, nil
        case risk.RiskActionReduce:
            tradingDecision.SizePercent = adjustedSize
        }
    }
    
    // Step 5: Final confidence check
    if result.Confidence < l.config.MinConfidence {
        result.Decision = ExecutionDecisionReject
        return result, nil
    }
    
    // Step 6: Approve and execute
    result.Decision = ExecutionDecisionApprove
    if l.config.AutoExecute {
        l.orderExecutor.ExecuteOrder(ctx, tradingDecision)
    }
    
    return result, nil
}

type AnalystAgentMetrics struct {
    TotalAnalyses    int64
    BuySignals       int64
    SellSignals      int64
    HoldSignals      int64
    AvgConfidence    float64
    AnalysesBySymbol map[string]int64
    AnalysesByRole   map[string]int64
}

type RiskManagerMetrics struct {
    TotalAssessments    int64
    ApprovedTrades      int64
    BlockedTrades       int64
    WarningsIssued      int64
    EmergencyTriggers   int64
    AssessmentsByRole   map[string]int64
    AssessmentsBySymbol map[string]int64
}

type ExecutionLoopMetrics struct {
    TotalCycles          int64
    ApprovedExecutions   int64
    RejectedExecutions   int64
    DeferredExecutions   int64
    EmergencyTriggers    int64
    TotalToolCalls       int64
    FailedToolCalls      int64
    AverageIterations    float64
    AverageExecutionTime float64
    AverageConfidence    float64
    DecisionsBySymbol    map[string]int64
    DecisionsByAction    map[string]int64
}