Regulatory & Accounting Alignment Agent

@tool(
    name="select_ifrs17_measurement_model",
    description="Rule-based selector: GMM vs PAA vs VFA based on product traits.",
    show_result=True,
)
def select_ifrs17_measurement_model(
    product_type: str,
    contract_length_years: float,
    has_direct_participation_features: bool,
    revenue_pattern: str = "level"
) -> Dict[str, Any]:
    """
    Select a plausible IFRS 17 measurement model(simplified rules).

    Args:
        product_type: e.g., 'short-tail non-life', 'life annuity', 'savings'
        contract_length_years: typical coverage duration in years
        has_direct_participation_features: True if direct participating contracts
        revenue_pattern: 'level'/'front-loaded' (informative only)

    Returns:
        Dict with selected model and rationale.
    """
    model = "GMM"
    rationale = []
    if has_direct_participation_features:
        model = "VFA"
        rationale.append("Direct participating features detected.")
    elif contract_length_years <= 1.0 and "non-life" in product_type.lower():
        model = "PAA"
        rationale.append("Short coverage period(<=1y) and non-life: PAA reasonable approximation.")
    else:
        rationale.append("Defaulting to GMM based on duration/features.")
    return {
        "selected_model": model,
        "rationale": rationale,
        "inputs": {
            "product_type": product_type,
            "contract_length_years": contract_length_years,
            "has_direct_participation_features": has_direct_participation_features,
            "revenue_pattern": revenue_pattern
        }
    }

@tool(
    name="build_qrt_simplified",
    description="Build a simplified Solvency II QRT-like snapshot from BEL, Risk Margin, Own Funds.",
    show_result=True,
)
def build_qrt_simplified(
    bel_net: float,
    risk_margin: float,
    own_funds: float
) -> Dict[str, Any]:
    """
    Construct a tiny QRT-like structure(highly simplified).

    Args:
        bel_net: Best Estimate Liabilities(net of reinsurance)
        risk_margin: Risk margin
        own_funds: Eligible own funds

    Returns:
        Dict with balance subtotals and solvency indicators.
    """
    technical_provisions = bel_net + risk_margin
    coverage = (own_funds / technical_provisions) if technical_provisions else 0.0
    return {
        "tp": {
            "bel_net": round(bel_net, 2),
            "risk_margin": round(risk_margin, 2),
            "technical_provisions": round(technical_provisions, 2),
        },
        "own_funds": round(own_funds, 2),
        "coverage_indicator": round(coverage, 4)
    }

@tool(
    name="reconcile_actuarial_to_ledger",
    description="Compare actuarial figures to ledger balances with tolerance flags.",
    show_result=True,
)
def reconcile_actuarial_to_ledger(
    actuarial: Dict[str, float],
    ledger: Dict[str, float],
    tolerance_abs: float = 1.0,
    tolerance_pct: float = 0.005
) -> Dict[str, Any]:
    """
    Reconcile key balances and flag differences.

    Args:
        actuarial: {"reserves": x, "premiums": y, "claims": z, ...}
        ledger: same keys as actuarial
        tolerance_abs: absolute difference tolerance
        tolerance_pct: percentage tolerance vs ledger

    Returns:
        Dict with differences, flags per key, and overall status.
    """
    diffs: Dict[str, Dict[str, Any]] = {}
    all_ok = True
    for k, led_val in ledger.items():
        act_val = actuarial.get(k, 0.0)
        diff = act_val - led_val
        pct = (diff / led_val) if led_val != 0 else 0.0
        ok = (abs(diff) <= tolerance_abs) or (abs(pct) <= tolerance_pct)
        if not ok:
            all_ok = False
        diffs[k] = {
            "actuarial": round(act_val, 2),
            "ledger": round(led_val, 2),
            "difference": round(diff, 2),
            "difference_pct_of_ledger": round(pct, 4),
            "within_tolerance": ok
        }
    return {
        "items": diffs,
        "overall_reconciled": all_ok,
        "tolerance_abs": tolerance_abs,
        "tolerance_pct": tolerance_pct
    }