Financial Actuarial Projections Agent

@tool(
    name="calculate_capital_requirements",
    description="Calculate SCR and MCR using standard formula approach",
    show_result=True,
)
def calculate_capital_requirements(
    risk_modules: Dict[str, float], business_volume: float, entity_type: str
) -> Dict[str, Any]:
    """
    Calculate SCR and MCR using standard formula approach.

    Args:
        risk_modules: Dictionary of risk module amounts
        business_volume: Annual business volume
        entity_type: Type of entity(life/health/non-life/multi)

    Returns:
        Dictionary containing capital requirements
    """
    total_scr = sum(risk_modules.values())
    correlation_benefit = total_scr * 0.15
    net_scr = total_scr - correlation_benefit
    mcr_ratio = 0.25 if entity_type == "life" else 0.30
    mcr = max(net_scr * mcr_ratio, 2200000 if entity_type == "life" else 1500000)
    risk_breakdown = {k: (v / total_scr * 100) if total_scr > 0 else 0 for k, v in risk_modules.items()}
    return {
        "scr_amount": round(net_scr, 0),
        "mcr_amount": round(mcr, 0),
        "total_risk": round(total_scr, 0),
        "diversification_benefit": round(correlation_benefit, 0),
        "risk_breakdown": risk_breakdown,
        "mcr_ratio": round((mcr / net_scr) * 100, 2) if net_scr > 0 else 0,
    }

@tool(
    name="ifrs17_solvency_bridge",
    description="Bridge between IFRS 17 profit emergence and Solvency II capital evolution",
    show_result=True,
)
def ifrs17_solvency_bridge(
    ifrs17_metrics: Dict[str, Any],
    solvency_metrics: Dict[str, Any],
    measurement_model: str,
) -> Dict[str, Any]:
    """
    Bridge between IFRS 17 profit emergence and Solvency II capital evolution.

    Args:
        ifrs17_metrics: IFRS 17 measurement metrics
        solvency_metrics: Solvency II metrics
        measurement_model: IFRS 17 measurement model(GMM/PAA/VFA)

    Returns:
        Dictionary containing bridge analysis
    """
    ifrs17_liability = ifrs17_metrics.get("fulfilment_cash_flows", 0)
    ifrs17_risk_adjustment = ifrs17_metrics.get("risk_adjustment", 0)
    ifrs17_csm = ifrs17_metrics.get("contractual_service_margin", 0)
    solvency_liability = solvency_metrics.get("technical_provisions", 0)
    solvency_risk_margin = solvency_metrics.get("risk_margin", 0)
    liability_difference = ifrs17_liability - solvency_liability
    risk_adjustment_difference = ifrs17_risk_adjustment - solvency_risk_margin
    ifrs17_profit_timing = "Immediate recognition of CSM" if measurement_model == "PAA" else "Recognition over service period"
    bridge_analysis = {
        "measurement_model": measurement_model,
        "liability_comparison": {
            "ifrs17_liability": ifrs17_liability,
            "solvency_liability": solvency_liability,
            "difference": liability_difference,
            "difference_percentage": (liability_difference / solvency_liability * 100) if solvency_liability > 0 else 0,
        },
        "risk_adjustment_comparison": {
            "ifrs17_risk_adjustment": ifrs17_risk_adjustment,
            "solvency_risk_margin": solvency_risk_margin,
            "difference": risk_adjustment_difference,
            "difference_percentage": (risk_adjustment_difference / solvency_risk_margin * 100) if solvency_risk_margin > 0 else 0,
        },
        "profit_recognition": {
            "ifrs17_timing": ifrs17_profit_timing,
            "solvency_timing": "Recognition based on capital adequacy",
            "csm_impact": ifrs17_csm,
            "capital_impact": "CSM affects own funds but not SCR",
        },
        "reconciliation": {
            "total_ifrs17_liability": ifrs17_liability + ifrs17_risk_adjustment,
            "total_solvency_liability": solvency_liability + solvency_risk_margin,
            "net_difference": (ifrs17_liability + ifrs17_risk_adjustment) - (solvency_liability + solvency_risk_margin),
        },
    }
    return bridge_analysis

@tool(
    name="project_solvency_evolution",
    description="Project solvency ratio evolution over time under different scenarios",
    show_result=True,
)
def project_solvency_evolution(
    current_solvency_ratio: float,
    current_scr: float,
    current_own_funds: float,
    projection_years: int,
    scenario_type: str,
    assumptions: Dict[str, Any],
) -> Dict[str, Any]:
    """
    Project solvency ratio evolution under different scenarios.

    Args:
        current_solvency_ratio: Current solvency ratio
        current_scr: Current SCR amount
        current_own_funds: Current own funds
        projection_years: Number of years to project
        scenario_type: Type of scenario(base/optimistic/pessimistic)
        assumptions: Dictionary of scenario assumptions

    Returns:
        Dictionary containing projected solvency metrics
    """
    scenario_multipliers = {
        "base": {"scr_growth": 1.02, "own_funds_growth": 1.05, "profit_margin": 0.08},
        "optimistic": {"scr_growth": 1.01, "own_funds_growth": 1.08, "profit_margin": 0.12},
        "pessimistic": {"scr_growth": 1.04, "own_funds_growth": 1.02, "profit_margin": 0.04},
    }
    multipliers = scenario_multipliers.get(scenario_type, scenario_multipliers["base"])
    current_scr_proj = current_scr
    current_own_funds_proj = current_own_funds
    projections = {}
    for year in range(1, projection_years + 1):
        current_scr_proj *= multipliers["scr_growth"]
        profit = current_own_funds_proj * multipliers["profit_margin"]
        current_own_funds_proj += profit
        solvency_ratio = (current_own_funds_proj / current_scr_proj) * 100
        projections[f"year_{year}"] = {
            "solvency_ratio": round(solvency_ratio, 2),
            "scr_amount": round(current_scr_proj, 0),
            "own_funds": round(current_own_funds_proj, 0),
            "profit": round(profit, 0),
            "capital_buffer": round(current_own_funds_proj - current_scr_proj, 0),
        }
    return {
        "scenario_type": scenario_type,
        "projection_years": projection_years,
        "assumptions": assumptions,
        "projections": projections,
    }