Actuarial & Financial Modeling Agent

@tool(
    name="calculate_life_insurance_premium",
    description="Calculate life insurance premium using actuarial principles",
    show_result=True,
)
def calculate_life_insurance_premium(
    age: int,
    gender: str,
    coverage_amount: float,
    policy_term: int,
    policy_type: str,
    smoker_status: bool,
    occupation_class: str,
) -> Dict[str, Any]:
    """
    Calculate life insurance premium using actuarial principles.

    Args:
        age: Age of the insured
        gender: Gender of the insured(male/female)
        coverage_amount: Death benefit amount
        policy_term: Policy term in years
        policy_type: Type of policy(term/whole/endowment/ulip)
        smoker_status: Whether the insured is a smoker
        occupation_class: Occupational risk class (A/B/C/D)

    Returns:
        Dictionary containing premium calculations and assumptions
    """    
    base_mortality = {
        "male": {20: 0.0005, 30: 0.0008, 40: 0.0012, 50: 0.0020, 60: 0.0040},
        "female": {20: 0.0003, 30: 0.0005, 40: 0.0008, 50: 0.0015, 60: 0.0030},
    }
    age_group = min((age // 10) * 10, 60)
    mortality_rate = base_mortality.get(gender.lower(), base_mortality["male"])[age_group]
    risk_multiplier = 1.0
    if smoker_status:
        risk_multiplier *= 2.5
    occupation_multipliers = {"A": 1.0, "B": 1.2, "C": 1.5, "D": 2.0}
    risk_multiplier *= occupation_multipliers.get(occupation_class.upper(), 1.0)
    net_premium = coverage_amount * mortality_rate * risk_multiplier
    policy_factors = {"term": 1.0, "whole": 1.8, "endowment": 2.2, "ulip": 1.5}
    net_premium *= policy_factors.get(policy_type.lower(), 1.0)
    expense_loading = net_premium * 0.25
    profit_margin = net_premium * 0.15
    gross_premium = net_premium + expense_loading + profit_margin
    return {
        "net_premium": round(net_premium, 2),
        "expense_loading": round(expense_loading, 2),
        "profit_margin": round(profit_margin, 2),
        "gross_premium": round(gross_premium, 2),
        "annual_premium": round(gross_premium, 2),
        "monthly_premium": round(gross_premium / 12, 2),
        "mortality_rate": mortality_rate,
        "risk_multiplier": risk_multiplier,
        "assumptions": {"age": age, "gender": gender, "coverage_amount": coverage_amount, "policy_term": policy_term, "policy_type": policy_type, "smoker_status": smoker_status, "occupation_class": occupation_class},
    }

@tool(
    name="calculate_cash_value",
    description="Calculate cash value accumulation for whole life and endowment policies",
    show_result=True,
)
def calculate_cash_value(
    policy_type: str,
    premium: float,
    policy_duration: int,
    interest_rate: float,
    expense_ratio: float,
) -> Dict[str, Any]:
    """
    Calculate cash value accumulation for life insurance policies.

    Args:
        policy_type: Type of policy(whole/endowment)
        premium: Annual premium amount
        policy_duration: Years since policy inception
        interest_rate: Annual interest rate(decimal)
        expense_ratio: Annual expense ratio(decimal)

    Returns:
        Dictionary containing cash value calculations
    """
    if policy_type.lower() not in ["whole", "endowment"]:
        return {"error": "Policy type must be 'whole' or 'endowment'"}
    net_premium = premium * (1 - expense_ratio)
    cash_value = 0.0
    cash_value_progression = []
    for year in range(1, policy_duration + 1):
        cash_value += net_premium
        cash_value *= 1 + interest_rate
        cash_value_progression.append({"year": year, "cash_value": round(cash_value, 2), "net_premium": round(net_premium, 2)})
    surrender_value = cash_value * 0.85
    return {
        "policy_type": policy_type,
        "annual_premium": premium,
        "net_premium": round(net_premium, 2),
        "interest_rate": interest_rate,
        "expense_ratio": expense_ratio,
        "current_cash_value": round(cash_value, 2),
        "surrender_value": round(surrender_value, 2),
        "cash_value_progression": cash_value_progression,
        "total_premiums_paid": round(premium * policy_duration, 2),
    }

@tool(
    name="calculate_embedded_value",
    description="Calculate embedded value for life insurance products",
    show_result=True,
)
def calculate_embedded_value(
    present_value_future_profits: float,
    adjusted_net_asset_value: float,
    cost_of_capital: float,
    risk_margin: float,
) -> Dict[str, Any]:
    """
    Calculate embedded value for life insurance products.

    Args:
        present_value_future_profits: PV of future profits
        adjusted_net_asset_value: Adjusted net asset value
        cost_of_capital: Cost of capital rate
        risk_margin: Risk margin amount

    Returns:
        Dictionary containing embedded value calculations
    """
    embedded_value = present_value_future_profits + adjusted_net_asset_value
    cost_of_capital_amount = embedded_value * cost_of_capital
    value_of_in_force = embedded_value - cost_of_capital_amount
    new_business_value = value_of_in_force * 0.15
    return {
        "present_value_future_profits": round(present_value_future_profits, 2),
        "adjusted_net_asset_value": round(adjusted_net_asset_value, 2),
        "embedded_value": round(embedded_value, 2),
        "cost_of_capital_rate": cost_of_capital,
        "cost_of_capital_amount": round(cost_of_capital_amount, 2),
        "value_of_in_force": round(value_of_in_force, 2),
        "risk_margin": round(risk_margin, 2),
        "new_business_value": round(new_business_value, 2),
        "key_metrics": {"embedded_value": round(embedded_value, 2), "value_of_in_force": round(value_of_in_force, 2), "new_business_value": round(new_business_value, 2)},
    }