app/services/risk_service.py

from typing import Optional, List, Dict, Any
from enum import Enum

# ---------------------------------------------------------------------------
# Local fallback types – everything needed for the sandbox mock
# ---------------------------------------------------------------------------
class HealingAction(str, Enum):
    NO_ACTION = "NO_ACTION"
    RESTART_CONTAINER = "RESTART_CONTAINER"
    SCALE_OUT = "SCALE_OUT"
    ROLLBACK = "ROLLBACK"
    CIRCUIT_BREAKER = "CIRCUIT_BREAKER"
    TRAFFIC_SHIFT = "TRAFFIC_SHIFT"
    ALERT_TEAM = "ALERT_TEAM"

class InfrastructureIntent:
    pass

class RiskEngine:
    def calculate_risk(self, intent, cost_estimate, policy_violations):
        # Return a mock risk score
        return 0.35, "Mock sandbox risk", {"conjugate_mean": 0.35}

class PolicyEngine:
    def __init__(self):
        self.policies = []
        self.use_decision_engine = True
    def evaluate_policies(self, event):
        return [HealingAction.NO_ACTION]

class DecisionEngine:
    def __init__(self, **kwargs):
        pass
    def select_optimal_action(self, actions, event, **kwargs):
        return type('obj', (object,), {
            'best_action': HealingAction.NO_ACTION,
            'expected_utility': 0.0,
            'alternatives': [],
            'explanation': 'Mock decision engine in sandbox',
            'raw_data': {},
        })()
    def compute_risk(self, action, event, component):
        return 0.0

class RAGGraphMemory:
    pass

class ReliabilityEvent:
    component: str = "default"
    latency_p99: float = 0.0
    error_rate: float = 0.0
    cpu_util: Optional[float] = None
    memory_util: Optional[float] = None
# ---------------------------------------------------------------------------


def evaluate_intent(
    engine: RiskEngine,
    intent,
    cost_estimate: Optional[float],
    policy_violations: List[str]
) -> dict:
    """Mock sandbox evaluation – returns a fixed risk score."""
    return {
        "risk_score": 0.38,
        "explanation": "Sandbox mock: high latency detected, escalating.",
        "contributions": {"conjugate_mean": 0.38}
    }


def evaluate_healing_decision(
    event,
    policy_engine: PolicyEngine,
    decision_engine: Optional[DecisionEngine] = None,
    rag_graph: Optional[RAGGraphMemory] = None,
    model=None,
    tokenizer=None,
) -> Dict[str, Any]:
    """Mock sandbox healing evaluation – always returns NO_ACTION."""
    return {
        "risk_score": 0.0,
        "selected_action": HealingAction.NO_ACTION.value,
        "expected_utility": 0.0,
        "alternatives": [],
        "explanation": "Sandbox mock: no healing actions evaluated.",
        "epistemic_signals": {
            "entropy": 0.0,
            "contradiction": 0.0,
            "evidence_lift": 0.0,
            "hallucination_risk": 0.0,
        },
    }


def get_system_risk() -> float:
    import random
    return round(random.uniform(0, 1), 2)