Product Design 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),
    }