Behavioral Analyses Agent

@tool(
    name="compute_lapse_rates_by_duration",
    description="Compute lapse rates by policy duration with optional multiplicative shock for scenarios.",
    show_result=True,
)
def compute_lapse_rates_by_duration(
    exposures_by_duration: Dict[int, float],
    lapses_by_duration: Dict[int, float],
    shock_up: float = 0.0
) -> Dict[str, Any]:
    """
    Compute base and shocked lapse rates by duration.

    Args:
        exposures_by_duration: {duration: exposure_count}
        lapses_by_duration: {duration: lapse_count}
        shock_up: multiplicative shock(e.g., 0.10 for +10%)

    Returns:
        Dict of base rates, shocked rates, and weighted averages.
    """
    base: Dict[int, float] = {}
    shocked: Dict[int, float] = {}
    total_exp = 0.0
    total_lap = 0.0

    for d, exp in exposures_by_duration.items():
        laps = lapses_by_duration.get(d, 0.0)
        rate = (laps / exp) if exp > 0 else 0.0
        base[d] = round(rate, 6)
        shocked[d] = round(rate * (1.0 + shock_up), 6)
        total_exp += exp
        total_lap += laps

    weighted_base = (total_lap / total_exp) if total_exp > 0 else 0.0
    weighted_shocked = weighted_base * (1.0 + shock_up)
    return {
        "base_lapse_rates_by_duration": base,
        "shocked_lapse_rates_by_duration": shocked,
        "weighted_base_lapse_rate": round(weighted_base, 6),
        "weighted_shocked_lapse_rate": round(weighted_shocked, 6),
        "shock_applied": shock_up
    }

@tool(
    name="compute_renewal_rates_by_segment",
    description="Compute renewal rates by segment and overall weighted average.",
    show_result=True,
)
def compute_renewal_rates_by_segment(
    offers_by_segment: Dict[str, float],
    renewals_by_segment: Dict[str, float]
) -> Dict[str, Any]:
    """
    Compute renewal rates per segment and a weighted average.

    Args:
        offers_by_segment: {segment: number_of_offers}
        renewals_by_segment: {segment: number_of_renewals}

    Returns:
        Dict with per-segment rates and weighted average.
    """
    rates: Dict[str, float] = {}
    tot_offers = 0.0
    tot_ren = 0.0
    for seg, offers in offers_by_segment.items():
        rens = renewals_by_segment.get(seg, 0.0)
        rate = (rens / offers) if offers > 0 else 0.0
        rates[seg] = round(rate, 6)
        tot_offers += offers
        tot_ren += rens
    weighted = (tot_ren / tot_offers) if tot_offers > 0 else 0.0
    return {
        "renewal_rate_by_segment": rates,
        "weighted_renewal_rate": round(weighted, 6),
        "totals": {"offers": tot_offers, "renewals": tot_ren}
    }

@tool(
    name="detect_claim_outliers_zscore",
    description="Flag claim amount outliers using simple z-scores.",
    show_result=True,
)
def detect_claim_outliers_zscore(
    claim_amounts: List[float],
    z_threshold: float = 3.0
) -> Dict[str, Any]:
    """
    Compute mean and std, then flag outliers with |z| > threshold.

    Args:
        claim_amounts: list of claim amounts
        z_threshold: threshold in standard deviations

    Returns:
        Dict with summary stats, outlier indices and values.
    """
    n = len(claim_amounts)
    if n == 0:
        return {"error": "Empty list."}
    mean = sum(claim_amounts) / n
    var = sum((x - mean) ** 2 for x in claim_amounts) / n
    std = var ** 0.5
    outliers: List[Tuple[int, float, float]] = []
    if std == 0:
        "color: #6b7280;"># All equal amounts
        return {
            "mean": round(mean, 2),
            "std": 0.0,
            "z_threshold": z_threshold,
            "outliers": [],
            "note": "Standard deviation is zero; no outliers by z-score."
        }
    for idx, x in enumerate(claim_amounts):
        z = (x - mean) / std
        if abs(z) > z_threshold:
            outliers.append((idx, round(x, 2), round(z, 3)))
    return {
        "mean": round(mean, 2),
        "std": round(std, 2),
        "z_threshold": z_threshold,
        "outliers": [{"index": i, "amount": v, "z": z} for i, v, z in outliers],
        "outliers_count": len(outliers)
    }