Technical Margins Analysis Agent

@tool(
    name="calculate_risk_margin_coc",
    description="Cost-of-Capital Risk Margin: sum(SCR_t * CoC / (1+r_t)^t). Requires scr_by_year(dict year -> SCR) and discount_curve(dict year -> rate), or omit for example values.",
    show_result=True,
)
def calculate_risk_margin_coc(
    cost_of_capital_rate: float,
    scr_by_year: Optional[Dict[int, float]] = None,
    discount_curve: Optional[Dict[int, float]] = None,
) -> Dict[str, Any]:
    """
    Compute Risk Margin using the cost-of-capital approach.

    Args:
        cost_of_capital_rate: annual CoC rate(e.g., 0.06)
        scr_by_year: optional {t: SCR_t}; if omitted, uses example {1: 100, 2: 80, 3: 60}
        discount_curve: optional {t: risk-free rate for year t}; if omitted, uses 2%% per year

    Returns:
        Dict with RM by year and total.
    """
    if scr_by_year is None:
        scr_by_year = {1: 100.0, 2: 80.0, 3: 60.0}
    if discount_curve is None:
        discount_curve = {t: 0.02 for t in scr_by_year}
    rm_by_year: Dict[int, float] = {}
    total_rm = 0.0
    for t, scr in scr_by_year.items():
        r = discount_curve.get(t, 0.0)
        term = scr * cost_of_capital_rate / ((1.0 + r) ** t)
        rm_by_year[t] = round(term, 2)
        total_rm += term
    return {
        "risk_margin_by_year": rm_by_year,
        "risk_margin_total": round(total_rm, 2),
        "parameters": {
            "cost_of_capital_rate": cost_of_capital_rate
        }
    }

@tool(
    name="technical_margin_analysis",
    description="Compute technical margin = Premium - Claims - Expenses - Commissions, plus key ratios.",
    show_result=True,
)
def technical_margin_analysis(
    premium_earned: float,
    claims_incurred: float,
    expenses: float,
    commissions: float = 0.0
) -> Dict[str, Any]:
    """
    Compute a basic technical margin and ratios.

    Args:
        premium_earned: Earned premium
        claims_incurred: Incurred claims
        expenses: Operating expenses
        commissions: Commissions/brokerage

    Returns:
        Dict with margin and ratios(loss, expense, combined).
    """
    margin = premium_earned - claims_incurred - expenses - commissions
    loss_ratio = (claims_incurred / premium_earned) if premium_earned else 0.0
    expense_ratio = (expenses / premium_earned) if premium_earned else 0.0
    commission_ratio = (commissions / premium_earned) if premium_earned else 0.0
    combined_ratio = loss_ratio + expense_ratio + commission_ratio
    return {
        "premium_earned": round(premium_earned, 2),
        "claims_incurred": round(claims_incurred, 2),
        "expenses": round(expenses, 2),
        "commissions": round(commissions, 2),
        "technical_margin": round(margin, 2),
        "ratios": {
            "loss_ratio": round(loss_ratio, 4),
            "expense_ratio": round(expense_ratio, 4),
            "commission_ratio": round(commission_ratio, 4),
            "combined_ratio": round(combined_ratio, 4),
        }
    }

@tool(
    name="variance_bridge_expected_to_actual",
    description="Simple variance bridge: Expected vs Actual for premium, claims, expenses. Pass expected and actual dicts, or omit for example values.",
    show_result=True,
)
def variance_bridge_expected_to_actual(
    expected: Optional[Dict[str, float]] = None,
    actual: Optional[Dict[str, float]] = None,
) -> Dict[str, Any]:
    """
    Decompose variance between Expected and Actual for key items.

    Args:
        expected: optional {"premium": x, "claims": y, "expenses": z}; if omitted uses example
        actual:   optional {"premium": x, "claims": y, "expenses": z}; if omitted uses example

    Returns:
        Dict with component variances, total variance, and percentage contributions.
    """
    if expected is None:
        expected = {"premium": 1000.0, "claims": 600.0, "expenses": 200.0}
    if actual is None:
        actual = {"premium": 1050.0, "claims": 620.0, "expenses": 190.0}
    keys = ["premium", "claims", "expenses"]
    components: Dict[str, float] = {}
    total = 0.0
    for k in keys:
        diff = actual.get(k, 0.0) - expected.get(k, 0.0)
        components[k] = round(diff, 2)
        total += diff

    pct_contrib = {k: (components[k] / total) if total != 0 else 0.0 for k in keys}
    return {
        "components": components,
        "total_variance": round(total, 2),
        "percentage_contribution": {k: round(v, 4) for k, v in pct_contrib.items()}
    }