decision/engine.py

from __future__ import annotations

from typing import Any, Dict, Optional

from shield.decision.scoring import decision_from_score
from shield.models.decisions import DECISION_ORDER


def choose_stronger_decision(first: str, second: str) -> str:
    if DECISION_ORDER.get(second, 0) > DECISION_ORDER.get(first, 0):
        return second
    return first


def build_decision(
    aggregate: Dict[str, Any],
    llm_result: Optional[Dict[str, Any]] = None,
) -> Dict[str, Any]:
    risk_score = int(aggregate.get("risk_score", 0))
    confidence = float(aggregate.get("confidence", 0.0))
    decision = decision_from_score(risk_score)
    reasons = list(aggregate.get("reasons", []))

    if llm_result:
        llm_score = int(llm_result.get("risk_score", 0))
        risk_score = max(risk_score, llm_score)
        confidence = max(confidence, float(llm_result.get("confidence", 0.0)))
        decision = choose_stronger_decision(decision_from_score(risk_score), str(llm_result.get("decision", decision)))
        for reason in llm_result.get("reasons", []):
            if isinstance(reason, str) and reason not in reasons:
                reasons.append(reason)
    else:
        decision = decision_from_score(risk_score)

    return {
        "risk_score": max(0, min(100, risk_score)),
        "confidence": round(max(0.0, min(1.0, confidence)), 2),
        "decision": decision,
        "recommended_action": decision,
        "reasons": reasons[:12],
    }