Strategic Integration Agent

@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,
    }

@tool(
    name="calculate_solvency_ratio",
    description="Calculate Solvency II ratio and capital adequacy metrics",
    show_result=True,
)
def calculate_solvency_ratio(
    own_funds: float,
    scr_amount: float,
    mcr_amount: float,
    risk_modules: Dict[str, float],
) -> Dict[str, Any]:
    """
    Calculate Solvency II ratio and capital adequacy metrics.

    Args:
        own_funds: Available own funds
        scr_amount: Solvency Capital Requirement
        mcr_amount: Minimum Capital Requirement
        risk_modules: Dictionary of risk module amounts

    Returns:
        Dictionary containing solvency metrics and analysis
    """
    solvency_ratio = (own_funds / scr_amount) * 100 if scr_amount > 0 else 0
    mcr_ratio = (own_funds / mcr_amount) * 100 if mcr_amount > 0 else 0
    total_risk = sum(risk_modules.values())
    risk_concentration = {
        k: (v / total_risk * 100) if total_risk > 0 else 0
        for k, v in risk_modules.items()
    }
    adequacy_level = (
        "Excellent"
        if solvency_ratio >= 150
        else(
            "Good"
            if solvency_ratio >= 130
            else "Adequate" if solvency_ratio >= 100 else "Inadequate"
        )
    )
    return {
        "solvency_ratio": round(solvency_ratio, 2),
        "mcr_ratio": round(mcr_ratio, 2),
        "adequacy_level": adequacy_level,
        "risk_concentration": risk_concentration,
        "capital_buffer": own_funds - scr_amount,
        "regulatory_margin": own_funds - mcr_amount,
    }

@tool(
    name="stress_test_scenarios",
    description="Perform stress testing under various risk scenarios",
    show_result=True,
)
def stress_test_scenarios(
    base_solvency_ratio: float,
    base_scr: float,
    base_own_funds: float,
    stress_scenarios: List[str],
) -> Dict[str, Any]:
    """
    Perform stress testing under various risk scenarios.

    Args:
        base_solvency_ratio: Base solvency ratio
        base_scr: Base SCR amount
        base_own_funds: Base own funds
        stress_scenarios: List of stress scenarios to test

    Returns:
        Dictionary containing stress test results
    """
    scenario_definitions = {
        "interest_rate_shock": {"description": "Parallel shift in interest rates", "scr_impact": 0.05, "own_funds_impact": -0.08},
        "equity_market_crash": {"description": "40% decline in equity markets", "scr_impact": 0.08, "own_funds_impact": -0.12},
        "mortality_stress": {"description": "Pandemic-like mortality increase", "scr_impact": 0.10, "own_funds_impact": -0.15},
        "lapse_shock": {"description": "Mass lapse event", "scr_impact": 0.04, "own_funds_impact": -0.06},
        "credit_default": {"description": "Sovereign default scenario", "scr_impact": 0.06, "own_funds_impact": -0.09},
        "operational_event": {"description": "Major operational failure", "scr_impact": 0.02, "own_funds_impact": -0.20},
    }
    stress_results = {}
    for scenario in stress_scenarios:
        if scenario in scenario_definitions:
            d = scenario_definitions[scenario]
            stressed_scr = base_scr * (1 + d["scr_impact"])
            stressed_own_funds = base_own_funds * (1 + d["own_funds_impact"])
            stressed_solvency_ratio = (stressed_own_funds / stressed_scr) * 100
            stress_results[scenario] = {
                "description": d["description"],
                "base_solvency_ratio": round(base_solvency_ratio, 2),
                "stressed_solvency_ratio": round(stressed_solvency_ratio, 2),
                "impact_on_solvency_ratio": round(stressed_solvency_ratio - base_solvency_ratio, 2),
                "stressed_scr": round(stressed_scr, 0),
                "stressed_own_funds": round(stressed_own_funds, 0),
                "adequacy_level": "Excellent" if stressed_solvency_ratio >= 150 else "Good" if stressed_solvency_ratio >= 130 else "Adequate" if stressed_solvency_ratio >= 100 else "Inadequate",
            }
    return {"base_metrics": {"solvency_ratio": base_solvency_ratio, "scr": base_scr, "own_funds": base_own_funds}, "stress_results": stress_results}