feat(admin): canaux IA par palier (z.ai/DeepSeek directs), emails generes par IA, reductions Stripe

- Chaque modele d'un palier devient une route {canal, modele} : openrouter,
  deepseek direct, zhipu (z.ai, nouveau canal), minimax, openai, xai ;
  repli automatique sur la route suivante si la cle manque, compatibilite
  ascendante avec les anciens reglages a chaines
- Page Fournisseurs refondue en sections ; interrupteurs et chaine de
  secours retablis ; tests de connexion avec delai d'attente
- Emails de relance generes par IA (canal au choix, prompt construit depuis
  le plan marketing, HTML sane, RTL arabe/persan, jamais d'envoi automatique)
- Codes promo : validation locale avant Stripe, Coupon+PromotionCode avec
  double plafond, comptage par session (webhook+sync=1 fois), ecriture
  atomique, relier-a-Stripe, suppression, validation publique au checkout
- Page Tarifs : champ code promo (?promo=) avec verification traduite
- Tests : 1357 verts (facturation par palier testee dans le worker,
  point de contact providers/available, promos, generation)

tests/test_ai_tier_routing.py

@@ -52,9 +52,12 @@ def client(monkeypatch, tmp_path: Path):
 def _settings(ai_tiers: dict | None = None):
     from routes.admin_routes import SettingsConfig
 
-    if ai_tiers is None:
-        return SettingsConfig()
-    return SettingsConfig.model_validate({"ai_tiers": ai_tiers})
+    # La résolution est clé-consciente : les tests de résolution partent avec
+    # une clé OpenRouter disponible (comme un serveur configuré).
+    payload = {"openrouter": {"api_key": "sk-or-test"}}
+    if ai_tiers is not None:
+        payload["ai_tiers"] = ai_tiers
+    return SettingsConfig.model_validate(payload)
 
 
 # ---------------------------------------------------------------------------
@@ -83,17 +86,17 @@ def test_old_single_model_keys_removed():
 
 
 # ---------------------------------------------------------------------------
-# Résolution par palier
+# Résolution par palier — renvoie la route complète (provider, model)
 # ---------------------------------------------------------------------------
 def test_pro_resolves_essential_plan_default():
     assert _resolve_tier_model(_settings(), "pro", premium=False) == (
-        "deepseek/deepseek-v4-flash"
+        ("openrouter", "deepseek/deepseek-v4-flash")
     )
 
 
 def test_business_resolves_premium_plan_default():
     assert _resolve_tier_model(_settings(), "business", premium=True) == (
-        "anthropic/claude-sonnet-5"
+        ("openrouter", "anthropic/claude-sonnet-5")
     )
 
 
@@ -101,7 +104,9 @@ def test_admin_tier_default_overrides_plan_default():
     cfg = _settings(
         {"essential": {"models": [], "default_model": "z-ai/glm-5.3-flash"}}
     )
-    assert _resolve_tier_model(cfg, "pro", premium=False) == "z-ai/glm-5.3-flash"
+    assert _resolve_tier_model(cfg, "pro", premium=False) == (
+        "openrouter", "z-ai/glm-5.3-flash"
+    )
 
 
 def test_admin_tier_models_first_used_when_default_empty():
@@ -113,7 +118,9 @@ def test_admin_tier_models_first_used_when_default_empty():
             }
         }
     )
-    assert _resolve_tier_model(cfg, "pro", premium=False) == "minimax/minimax-m3"
+    assert _resolve_tier_model(cfg, "pro", premium=False) == (
+        "openrouter", "minimax/minimax-m3"
+    )
 
 
 def test_pro_never_resolves_premium_model():
@@ -124,7 +131,8 @@ def test_pro_never_resolves_premium_model():
         }
     )
     for plan_str in ("pro", "PlanType.PRO"):
-        model = _resolve_tier_model(cfg, plan_str, premium=False)
+        provider, model = _resolve_tier_model(cfg, plan_str, premium=False)
+        assert provider == "openrouter"
         assert model in DEFAULT_AI_MODELS_ESSENTIAL
         assert model not in DEFAULT_AI_MODELS_PREMIUM
 
@@ -155,3 +163,68 @@ def test_get_plans_exposes_model_lists(client):
     ]
     assert plans["business"]["ai_models_premium"][0] == "anthropic/claude-sonnet-5"
     assert "ai_model_essential" not in plans["pro"]
+
+
+# ---------------------------------------------------------------------------
+# Point de contact : GET /providers/available affiche le modèle (chaîne simple)
+# ---------------------------------------------------------------------------
+def test_available_providers_model_is_a_string(monkeypatch, tmp_path):
+    """``_resolve_tier_model`` renvoie désormais (provider, model) : le champ
+    « model » de /providers/available doit rester une chaîne, égale au modèle
+    attendu pour les deux paliers (appelé ici avec un utilisateur Business,
+    car la liste est filtrée par forfait)."""
+    import routes.legacy_routes as legacy_mod
+    import routes.admin_routes as admin_routes_mod
+
+    settings = _settings(
+        {
+            "essential": {"models": [], "default_model": "z-ai/glm-5.3-flash"},
+            "premium": {"models": [], "default_model": "anthropic/claude-sonnet-5"},
+        }
+    )
+    # Les deux passerelles sont affichées dès lors qu'elles sont actives côté
+    # réglages (indépendamment des variables d'environnement de la machine).
+    settings.openrouter.enabled = True
+    settings.openrouter_premium.enabled = True
+    monkeypatch.setattr(admin_routes_mod, "load_settings", lambda: settings, raising=True)
+
+    from fastapi.testclient import TestClient
+    from middleware.rate_limiting import RateLimitManager
+    from models.subscription import PlanType
+
+    async def _check_request_allow(self, request):
+        return True, "ok", "test"
+
+    async def _check_translation_allow(self, request, file_size_mb=0):
+        return True, "ok"
+
+    monkeypatch.setattr(RateLimitManager, "check_request", _check_request_allow)
+    monkeypatch.setattr(RateLimitManager, "check_translation", _check_translation_allow)
+
+    import services.auth_service as auth_svc
+
+    monkeypatch.setattr(auth_svc, "USERS_FILE", tmp_path / "users.json")
+    monkeypatch.setattr(auth_svc, "USE_DATABASE", False)
+    monkeypatch.setattr(auth_svc, "DATABASE_AVAILABLE", False)
+
+    # Utilisateur Business factice (les moteurs Premium sont filtrés par plan).
+    business_user = type("U", (), {"plan": PlanType.BUSINESS, "id": "u-biz"})()
+
+    async def _fake_user():
+        return business_user
+
+    from main import app
+
+    app.dependency_overrides[legacy_mod.get_authenticated_user] = _fake_user
+    try:
+        with TestClient(app, raise_server_exceptions=True) as tc:
+            r = tc.get("/api/v1/providers/available")
+    finally:
+        app.dependency_overrides.pop(legacy_mod.get_authenticated_user, None)
+
+    assert r.status_code == 200, r.text
+    engines = {e["id"]: e for e in r.json()["providers"]}
+    assert isinstance(engines["openrouter"]["model"], str)
+    assert engines["openrouter"]["model"] == "z-ai/glm-5.3-flash"
+    assert isinstance(engines["openrouter_premium"]["model"], str)
+    assert engines["openrouter_premium"]["model"] == "anthropic/claude-sonnet-5"